next-api-mock 1.0.0 → 1.0.1

package/__tests__/configValidator.test.ts

@@ -1,5 +1,5 @@
 import { validateConfig } from '../src/configValidator'
-import { MockConfig, MockFunction } from '../src/types'
+import { MockConfig, MockFunction, MockResponse } from '../src/types'
 import { NextApiRequest } from 'next'
 import { NextRequest } from 'next/server'
 
@@ -10,7 +10,7 @@ describe('Config Validator', () => {
                 status: 200,
                 data: { message: 'Test successful' },
             },
-            '/api/function': ((req: NextApiRequest | NextRequest) => ({
+            '/api/function': (async (req: NextApiRequest | NextRequest) => ({
                 status: 200,
                 data: { method: req.method },
             })) as MockFunction,
@@ -58,7 +58,7 @@ describe('Config Validator', () => {
 
     it('should pass for valid function configurations', () => {
         const validConfig: MockConfig = {
-            '/api/function': ((req: NextApiRequest | NextRequest) => ({
+            '/api/function': (async (req: NextApiRequest | NextRequest): Promise<MockResponse> => ({
                 status: 200,
                 data: { method: req.method },
             })) as MockFunction,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-api-mock",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A production-ready, scalable tool for mocking API and GraphQL responses in Next.js applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core.ts

@@ -0,0 +1,380 @@
+import { EventEmitter } from 'events'
+import * as winston from 'winston'
+import config from 'config'
+import { parse } from 'url'
+import { match } from 'path-to-regexp'
+import { isAppRouter, isNextJs12, isNextJs13, isNextJs14, isNextJs15, getNextVersion } from './utils/versionCheck'
+import {
+    MockResponse,
+    MockConfig,
+    RequestLogger,
+    MockInterceptor,
+    MockOptions,
+    MiddlewareFunction,
+    MockFunction,
+    AnyRequest,
+    AnyResponse,
+    isNextApiRequest as typeGuardIsNextApiRequest,
+    isNextRequest
+} from './types'
+import { validateConfig } from './configValidator'
+import { applyMiddleware } from './middleware'
+import { cacheResponse, getCachedResponse, clearCache } from './cache'
+import { configureServerMocks, resetServerMocks, mockServerAction, createServerComponentMock } from './serverMock'
+import { initializePlugins, registerPlugin } from './plugins'
+import { setSecureHeaders as localSetSecureHeaders } from './security'
+import { collectMetrics, reportMetrics } from './monitoring'
+import { createRequestValidator } from './validation'
+import { createRateLimiter } from './rateLimit'
+import { createMockDatabase } from './mockDatabase'
+import { createGraphQLMockHandler } from './graphqlMock'
+
+import type { NextApiRequest, NextApiResponse } from 'next'
+import { NextRequest, NextResponse } from 'next/server'
+
+const logger = winston.createLogger({
+    level: config.get<string>('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: MockConfig = {}
+const defaultOptions: MockOptions = {
+    enableLogging: false,
+    cacheTimeout: 5 * 60 * 1000, // 5 minutes
+    defaultDelay: 0,
+    errorRate: 0,
+}
+
+let mockConfig: MockConfig = { ...defaultConfig }
+let mockOptions: MockOptions = { ...defaultOptions }
+let globalDelay = 0
+let requestLogger: RequestLogger | null = null
+let mockInterceptor: MockInterceptor | null = null
+const eventEmitter = new EventEmitter()
+const middlewarePipeline: MiddlewareFunction[] = []
+
+export async function configureMocksAsync(configPromise: Promise<MockConfig>, options?: Partial<MockOptions>): Promise<void> {
+    try {
+        const loadedConfig = await configPromise
+        configureMocks(loadedConfig, options)
+    } catch (error) {
+        logger.error('Error loading configuration:', error)
+        throw new Error('Failed to load mock configuration')
+    }
+}
+
+export function configureMocks(loadedConfig: MockConfig, options?: Partial<MockOptions>): void {
+    try {
+        validateConfig(loadedConfig)
+        mockConfig = { ...defaultConfig, ...loadedConfig }
+        mockOptions = { ...defaultOptions, ...options }
+        if (mockOptions.enableLogging) {
+            setRequestLogger(defaultLogger)
+        }
+        if (mockOptions.defaultDelay) {
+            setGlobalDelay(mockOptions.defaultDelay)
+        }
+        initializePlugins(mockConfig)
+    } catch (error) {
+        logger.error('Error configuring mocks:', error)
+        throw new Error('Failed to configure mocks')
+    }
+}
+
+export function resetMocks(): void {
+    mockConfig = { ...defaultConfig }
+    mockOptions = { ...defaultOptions }
+    globalDelay = 0
+    requestLogger = null
+    mockInterceptor = null
+    clearCache()
+    resetServerMocks()
+}
+
+export function setGlobalDelay(delay: number): void {
+    globalDelay = delay
+}
+
+export function setRequestLogger(logger: RequestLogger): void {
+    requestLogger = logger
+}
+
+export function setMockInterceptor(interceptor: MockInterceptor): void {
+    mockInterceptor = interceptor
+}
+
+export function onMockResponse(listener: (path: string, response: MockResponse<unknown>) => void): () => void {
+    eventEmitter.on('mockResponse', listener)
+    return () => eventEmitter.off('mockResponse', listener)
+}
+
+export function addMiddleware(middleware: MiddlewareFunction): void {
+    middlewarePipeline.push(middleware)
+}
+
+function defaultLogger(req: AnyRequest, res: AnyResponse): void {
+    let status: number
+    if (isNextApiResponse(res)) {
+        status = res.statusCode
+    } else if ('status' in res) {
+        status = res.status
+    } else {
+        status = 200 // Default status if not found
+    }
+    logger.info(`${req.method} ${req.url} - Status: ${status}`)
+}
+
+function shouldSimulateError(): boolean {
+    return Math.random() < mockOptions.errorRate
+}
+
+const limiter = createRateLimiter({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100 // limit each IP to 100 requests per windowMs
+})
+
+export function createMockHandler(path: string) {
+    if (isAppRouter) {
+        return createAppRouterHandler(path)
+    } else {
+        return createPagesApiHandler(path)
+    }
+}
+
+function createAppRouterHandler(path: string) {
+    return async (req: NextRequest, context: { params: any }): Promise<NextResponse> => {
+        try {
+            if (isNextRequest(req)) {
+                // Handle NextRequest (App Router)
+                const headers = new Headers(req.headers)
+                headers.set('X-Secure-Header', 'true')
+                const secureReq = new NextRequest(req.url, {
+                    headers,
+                    method: req.method,
+                    body: req.body,
+                    cache: req.cache,
+                    credentials: req.credentials,
+                    integrity: req.integrity,
+                    keepalive: req.keepalive,
+                    mode: req.mode,
+                    redirect: req.redirect,
+                    referrer: req.referrer,
+                    referrerPolicy: req.referrerPolicy,
+                    signal: req.signal,
+                })
+
+                // Process the request with the new headers
+                return handleRequest(secureReq, path)
+            } else {
+                throw new Error('Unexpected request type in App Router handler')
+            }
+        } catch (error) {
+            logger.error('Error in App Router handler:', error)
+            return NextResponse.json({ error: 'Internal server error', details: (error as Error).message }, { status: 500 })
+        }
+    }
+}
+
+function createPagesApiHandler(path: string) {
+    return limiter(async (req: NextApiRequest, res: NextApiResponse): Promise<void> => {
+        try {
+            if (typeGuardIsNextApiRequest(req)) {
+                localSetSecureHeaders(res)
+                await handleApiRequest(req, res, path)
+            } else {
+                throw new Error('Unexpected request type in Pages API handler')
+            }
+        } catch (error) {
+            logger.error('Error in Pages API handler:', error)
+            res.status(500).json({ error: 'Internal server error', details: (error as Error).message })
+        }
+    })
+}
+
+async function handleRequest(req: NextRequest, path: string): Promise<NextResponse> {
+    if (shouldSimulateError()) {
+        throw new Error('Simulated server error')
+    }
+
+    for (const middleware of middlewarePipeline) {
+        await middleware(req as unknown as AnyRequest, NextResponse.next() as unknown as AnyResponse)
+    }
+
+    const cacheKey = `${req.method}:${path}:${JSON.stringify(Object.fromEntries(req.nextUrl.searchParams))}:${await req.text()}`
+    const cachedResponse = getCachedResponse(cacheKey)
+
+    if (cachedResponse) {
+        return NextResponse.json(cachedResponse.data, { status: cachedResponse.status || 200 })
+    }
+
+    const { pathname } = new URL(req.url)
+    const matchFn = match(path, { decode: decodeURIComponent })
+
+    if (pathname === null) {
+        return NextResponse.json({ error: 'Invalid URL' }, { status: 400 })
+    }
+
+    const matched = matchFn(pathname)
+
+    if (!matched) {
+        return NextResponse.json({ error: 'Not found' }, { status: 404 })
+    }
+
+    let mockResponse: MockResponse<unknown>
+    const mockConfigItem = mockConfig[path]
+
+    if (typeof mockConfigItem === 'function') {
+        mockResponse = await (mockConfigItem as MockFunction)(req as unknown as AnyRequest)
+    } else {
+        mockResponse = mockConfigItem as MockResponse<unknown>
+    }
+
+    if (!mockResponse) {
+        return NextResponse.json({ error: 'Not found' }, { status: 404 })
+    }
+
+    mockResponse = await applyMiddleware(req as unknown as AnyRequest, mockResponse, mockInterceptor)
+
+    if (requestLogger) {
+        requestLogger(req as unknown as AnyRequest, NextResponse.json({}, { status: mockResponse.status || 200 }) as unknown as AnyResponse)
+    }
+
+    const delay = mockResponse.delay || globalDelay
+    if (delay) {
+        await new Promise(resolve => setTimeout(resolve, delay))
+    }
+
+    eventEmitter.emit('mockResponse', path, mockResponse)
+    collectMetrics(req as unknown as AnyRequest, NextResponse.json({}, { status: mockResponse.status || 200 }) as unknown as AnyResponse, mockResponse)
+
+    cacheResponse(cacheKey, mockResponse, mockOptions.cacheTimeout)
+
+    return NextResponse.json(mockResponse.data, {
+        status: mockResponse.status || 200,
+        headers: mockResponse.headers,
+    })
+}
+
+async function handleApiRequest(req: NextApiRequest, res: NextApiResponse, path: string): Promise<void> {
+    if (shouldSimulateError()) {
+        throw new Error('Simulated server error')
+    }
+
+    for (const middleware of middlewarePipeline) {
+        await middleware(req, res)
+    }
+
+    const cacheKey = `${req.method}:${path}:${JSON.stringify(req.query)}:${JSON.stringify(req.body)}`
+    const cachedResponse = getCachedResponse(cacheKey)
+
+    if (cachedResponse) {
+        res.status(cachedResponse.status || 200).json(cachedResponse.data)
+        return
+    }
+
+    const { pathname } = parse(req.url || '', true)
+    const matchFn = 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: MockResponse<unknown>
+    const mockConfigItem = mockConfig[path]
+
+    if (typeof mockConfigItem === 'function') {
+        mockResponse = await (mockConfigItem as MockFunction)(req)
+    } else {
+        mockResponse = mockConfigItem as MockResponse<unknown>
+    }
+
+    if (!mockResponse) {
+        res.status(404).json({ error: 'Not found' })
+        return
+    }
+
+    mockResponse = await applyMiddleware(req, mockResponse, mockInterceptor)
+
+    if (requestLogger) {
+        requestLogger(req, res)
+    }
+
+    const delay = mockResponse.delay || globalDelay
+    if (delay) {
+        await new Promise(resolve => setTimeout(resolve, delay))
+    }
+
+    if (mockResponse.headers) {
+        Object.entries(mockResponse.headers).forEach(([key, value]) => {
+            res.setHeader(key, value as string)
+        })
+    }
+
+    eventEmitter.emit('mockResponse', path, mockResponse)
+    collectMetrics(req, res, mockResponse)
+
+    cacheResponse(cacheKey, mockResponse, mockOptions.cacheTimeout)
+
+    res.status(mockResponse.status || 200).json(mockResponse.data)
+}
+
+function isNextApiRequest(req: AnyRequest): req is NextApiRequest {
+    return typeGuardIsNextApiRequest(req)
+}
+
+function isNextApiResponse(res: AnyResponse): res is NextApiResponse {
+    return 'status' in res && typeof res.status === 'function'
+}
+
+function setSecureHeaders(reqOrRes: NextRequest | NextApiResponse): NextRequest | void {
+    if (reqOrRes instanceof NextRequest) {
+        // For NextRequest, we can't set headers directly, but we can create a new request with added headers
+        const headers = new Headers(reqOrRes.headers)
+        headers.set('X-Secure-Header', 'true')
+        return new NextRequest(reqOrRes.url, {
+            headers,
+            method: reqOrRes.method,
+            body: reqOrRes.body,
+            cache: reqOrRes.cache,
+            credentials: reqOrRes.credentials,
+            integrity: reqOrRes.integrity,
+            keepalive: reqOrRes.keepalive,
+            mode: reqOrRes.mode,
+            redirect: reqOrRes.redirect,
+            referrer: reqOrRes.referrer,
+            referrerPolicy: reqOrRes.referrerPolicy,
+            signal: reqOrRes.signal,
+        })
+    } else {
+        // Handle NextApiResponse (Pages Router)
+        localSetSecureHeaders(reqOrRes)
+    }
+}
+
+export {
+    createMockDatabase,
+    createGraphQLMockHandler,
+    configureServerMocks,
+    resetServerMocks,
+    mockServerAction,
+    createServerComponentMock,
+    registerPlugin,
+    reportMetrics,
+    createRequestValidator,
+    setSecureHeaders
+}
+

package/src/index.ts

@@ -1,210 +1,47 @@
-import { NextApiRequest, NextApiResponse } from 'next'
-import { parse } from 'url'
-import { match } from 'path-to-regexp'
-import { EventEmitter } from 'events'
-import * as winston from 'winston'
-import config from 'config'
-import { MockResponse, MockConfig, RequestLogger, MockInterceptor, MockOptions, MiddlewareFunction, MockFunction } from './types'
-import { createMockDatabase } from './mockDatabase'
-import { createGraphQLMockHandler } from './graphqlMock'
-import { validateConfig } from './configValidator'
-import { applyMiddleware } from './middleware'
-import { cacheResponse, getCachedResponse, clearCache } from './cache'
-import { configureServerMocks, resetServerMocks, mockServerAction, createServerComponentMock } from './serverMock'
-import { initializePlugins, registerPlugin } from './plugins'
-import { setSecureHeaders } from './security'
-import { collectMetrics, reportMetrics } from './monitoring'
-import { createRequestValidator } from './validation'
-import { createRateLimiter } from './rateLimit'
+// Core functionality
+export { configureMocks, configureMocksAsync, resetMocks, setGlobalDelay, setRequestLogger, setMockInterceptor, onMockResponse, addMiddleware, createMockHandler } from './core'
 
-const logger = winston.createLogger({
-    level: config.get<string>('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' }),
-    ],
-})
+// Server-side mocking
+export { configureServerMocks, resetServerMocks, mockServerAction, createServerComponentMock } from './serverMock'
 
-const defaultConfig: MockConfig = {}
-const defaultOptions: MockOptions = {
-    enableLogging: false,
-    cacheTimeout: 5 * 60 * 1000, // 5 minutes
-    defaultDelay: 0,
-    errorRate: 0,
-}
+// Database and GraphQL mocking
+export { createMockDatabase } from './mockDatabase'
+export { createGraphQLMockHandler } from './graphqlMock'
 
-let mockConfig: MockConfig = { ...defaultConfig }
-let mockOptions: MockOptions = { ...defaultOptions }
-let globalDelay = 0
-let requestLogger: RequestLogger | null = null
-let mockInterceptor: MockInterceptor | null = null
-const eventEmitter = new EventEmitter()
-const middlewarePipeline: MiddlewareFunction[] = []
+// Plugins and metrics
+export { registerPlugin } from './plugins'
+export { reportMetrics } from './monitoring'
 
-export async function configureMocksAsync(configPromise: Promise<MockConfig>, options?: Partial<MockOptions>): Promise<void> {
-    try {
-        const loadedConfig = await configPromise
-        configureMocks(loadedConfig, options)
-    } catch (error) {
-        logger.error('Error loading configuration:', error)
-        throw new Error('Failed to load mock configuration')
-    }
-}
+// Validation and security
+export { createRequestValidator } from './validation'
+export { setSecureHeaders } from './security'
 
-export function configureMocks(loadedConfig: MockConfig, options?: Partial<MockOptions>): void {
-    try {
-        validateConfig(loadedConfig)
-        mockConfig = { ...defaultConfig, ...loadedConfig }
-        mockOptions = { ...defaultOptions, ...options }
-        if (mockOptions.enableLogging) {
-            setRequestLogger(defaultLogger)
-        }
-        if (mockOptions.defaultDelay) {
-            setGlobalDelay(mockOptions.defaultDelay)
-        }
-        initializePlugins(mockConfig)
-    } catch (error) {
-        logger.error('Error configuring mocks:', error)
-        throw new Error('Failed to configure mocks')
-    }
-}
+// Types
+export type {
+    MockResponse,
+    MockConfig,
+    RequestLogger,
+    MockInterceptor,
+    MockOptions,
+    MiddlewareFunction,
+    MockFunction,
+    AnyRequest,
+    AnyResponse
+} from './types'
 
-export function resetMocks(): void {
-    mockConfig = { ...defaultConfig }
-    mockOptions = { ...defaultOptions }
-    globalDelay = 0
-    requestLogger = null
-    mockInterceptor = null
-    clearCache()
-    resetServerMocks()
-}
+// Version check utilities
+export { isAppRouter, isNextJs12, isNextJs13, isNextJs14, isNextJs15, getNextVersion } from './utils/versionCheck'
 
-export function setGlobalDelay(delay: number): void {
-    globalDelay = delay
-}
+// Config validation
+export { validateConfig } from './configValidator'
 
-export function setRequestLogger(logger: RequestLogger): void {
-    requestLogger = logger
-}
+// Middleware
+export { applyMiddleware } from './middleware'
 
-export function setMockInterceptor(interceptor: MockInterceptor): void {
-    mockInterceptor = interceptor
-}
+// Caching
+export { cacheResponse, getCachedResponse, clearCache } from './cache'
 
-export function onMockResponse(listener: (path: string, response: MockResponse<unknown>) => void): () => void {
-    eventEmitter.on('mockResponse', listener)
-    return () => eventEmitter.off('mockResponse', listener)
-}
+// Rate limiting
+export { createRateLimiter } from './rateLimit'
 
-export function addMiddleware(middleware: MiddlewareFunction): void {
-    middlewarePipeline.push(middleware)
-}
-
-function defaultLogger(req: NextApiRequest, res: NextApiResponse): void {
-    logger.info(`${req.method} ${req.url} - Status: ${res.statusCode}`)
-}
-
-function shouldSimulateError(): boolean {
-    return Math.random() < mockOptions.errorRate
-}
-
-const limiter = createRateLimiter({
-    windowMs: 15 * 60 * 1000, // 15 minutes
-    max: 100 // limit each IP to 100 requests per windowMs
-})
-
-export function createMockHandler(path: string) {
-    return limiter(async (req: NextApiRequest, res: NextApiResponse): Promise<void> => {
-        try {
-            setSecureHeaders(res)
-
-            if (shouldSimulateError()) {
-                throw new Error('Simulated server error')
-            }
-
-            for (const middleware of middlewarePipeline) {
-                await middleware(req, res)
-            }
-
-            const cacheKey = `${req.method}:${path}:${JSON.stringify(req.query)}:${JSON.stringify(req.body)}`
-            const cachedResponse = getCachedResponse(cacheKey)
-
-            if (cachedResponse) {
-                res.status(cachedResponse.status || 200).json(cachedResponse.data)
-                return
-            }
-
-            const { pathname } = parse(req.url || '', true)
-            const matchFn = 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: MockResponse<unknown>
-            const mockConfigItem = mockConfig[path]
-
-            if (typeof mockConfigItem === 'function') {
-                mockResponse = await (mockConfigItem as MockFunction)(req)
-            } else {
-                mockResponse = mockConfigItem as MockResponse<unknown>
-            }
-
-            if (!mockResponse) {
-                res.status(404).json({ error: 'Not found' })
-                return
-            }
-
-            mockResponse = await applyMiddleware(req, mockResponse, mockInterceptor)
-
-            if (requestLogger) {
-                requestLogger(req, res)
-            }
-
-            const delay = mockResponse.delay || globalDelay
-            if (delay) {
-                await new Promise(resolve => setTimeout(resolve, delay))
-            }
-
-            if (mockResponse.headers) {
-                Object.entries(mockResponse.headers).forEach(([key, value]) => {
-                    res.setHeader(key, value as string)
-                })
-            }
-
-            eventEmitter.emit('mockResponse', path, mockResponse)
-            collectMetrics(req, res, mockResponse)
-
-            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 as Error).message })
-        }
-    })
-}
-
-export {
-    createMockDatabase,
-    createGraphQLMockHandler,
-    configureServerMocks,
-    resetServerMocks,
-    mockServerAction,
-    createServerComponentMock,
-    registerPlugin,
-    reportMetrics,
-    createRequestValidator
-}