next-api-mock 1.0.0

package/src/graphqlMock.ts

@@ -0,0 +1,44 @@
+import { NextApiRequest } from 'next'
+import { graphql, GraphQLSchema } from 'graphql'
+import { MockResponse } from './types'
+
+export function createGraphQLMockHandler(schema: GraphQLSchema) {
+    return async (req: NextApiRequest): Promise<MockResponse> => {
+        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 = await 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/src/index.ts

@@ -0,0 +1,210 @@
+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'
+
+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: 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
+}
+

package/src/middleware.ts

@@ -0,0 +1,14 @@
+import { NextApiRequest } from 'next'
+import { MockResponse, MockInterceptor } from './types'
+
+export async function applyMiddleware(
+    req: NextApiRequest,
+    response: MockResponse,
+    interceptor: MockInterceptor | null
+): Promise<MockResponse> {
+    if (interceptor) {
+        return await interceptor(req, response)
+    }
+    return response
+}
+

package/src/mockDatabase.ts

@@ -0,0 +1,33 @@
+export function createMockDatabase<T extends { id: string | number }>() {
+    let data: T[] = []
+
+    return {
+        getAll: () => [...data],
+        getById: (id: string | number) => data.find(item => item.id === id),
+        create: (item: T) => {
+            data.push(item)
+            return item
+        },
+        update: (id: string | number, updates: Partial<T>) => {
+            const index = data.findIndex(item => item.id === id)
+            if (index !== -1) {
+                data[index] = { ...data[index], ...updates }
+                return data[index]
+            }
+            return null
+        },
+        delete: (id: string | number) => {
+            const index = data.findIndex(item => item.id === id)
+            if (index !== -1) {
+                const deleted = data[index]
+                data.splice(index, 1)
+                return deleted
+            }
+            return null
+        },
+        reset: () => {
+            data = []
+        },
+        query: (predicate: (item: T) => boolean) => data.filter(predicate)
+    }
+}

package/src/monitoring.ts

@@ -0,0 +1,47 @@
+import * as prometheus from 'prom-client'
+import { NextApiRequest, NextApiResponse } from 'next'
+import { MockResponse } from './types'
+
+const requestCounter = new prometheus.Counter({
+    name: 'mock_requests_total',
+    help: 'Total number of mock requests',
+    labelNames: ['method', 'path', 'status'],
+})
+
+const responseTimeHistogram = new prometheus.Histogram({
+    name: 'mock_response_time_seconds',
+    help: 'Response time in seconds',
+    labelNames: ['method', 'path'],
+})
+
+/**
+ * Collects metrics for a mock request.
+ * @param req The incoming request.
+ * @param res The outgoing response.
+ * @param mockResponse The mock response.
+ */
+export function collectMetrics(req: NextApiRequest, res: NextApiResponse, mockResponse: MockResponse): void {
+    const labels = {
+        method: req.method || 'UNKNOWN',
+        path: req.url || 'UNKNOWN',
+        status: mockResponse.status.toString(),
+    }
+
+    requestCounter.inc(labels)
+
+    const responseTime = process.hrtime()
+    res.on('finish', () => {
+        const [seconds, nanoseconds] = process.hrtime(responseTime)
+        const duration = seconds + nanoseconds / 1e9
+        responseTimeHistogram.observe({ method: labels.method, path: labels.path }, duration)
+    })
+}
+
+/**
+ * Reports the collected metrics.
+ * @returns A Promise that resolves to a string representation of the collected metrics.
+ */
+export async function reportMetrics(): Promise<string> {
+    return await prometheus.register.metrics()
+}
+

package/src/plugins.ts

@@ -0,0 +1,16 @@
+import { MockConfig, Plugin } from './types'
+const plugins: Plugin[] = []
+/**
+ * Registers a new plugin.
+ * @param plugin The plugin to register.
+ */
+export function registerPlugin(plugin: Plugin): void {
+    plugins.push(plugin)
+}
+/**
+ * Initializes all registered plugins with the provided configuration.
+ * @param config The mock configuration.
+ */
+export function initializePlugins(config: MockConfig): void {
+    plugins.forEach(plugin => plugin.initialize(config))
+}

package/src/rateLimit.ts

@@ -0,0 +1,26 @@
+import { NextApiRequest, NextApiResponse } from 'next'
+import { rateLimit, Options } from 'express-rate-limit'
+import { Request, Response, NextFunction } from 'express'
+
+type NextApiHandler = (req: NextApiRequest, res: NextApiResponse) => Promise<void>
+
+export function createRateLimiter(options: Partial<Options>) {
+    const limiter = rateLimit(options)
+
+    return function rateLimitMiddleware(handler: NextApiHandler): NextApiHandler {
+        return async (req: NextApiRequest, res: NextApiResponse) => {
+            const expressReq = req as unknown as Request
+            const expressRes = res as unknown as Response
+
+            return new Promise<void>((resolve, reject) => {
+                limiter(expressReq, expressRes, (result: any) => {
+                    if (result instanceof Error) {
+                        return reject(result)
+                    }
+                    return resolve(handler(req, res))
+                })
+            })
+        }
+    }
+}
+

package/src/security.ts

@@ -0,0 +1,42 @@
+import { NextApiResponse } from 'next'
+import helmet from 'helmet'
+import { IncomingMessage, ServerResponse } from 'http'
+
+/**
+ * Sets secure headers on the response using helmet.
+ * @param res The Next.js API response object.
+ */
+export function setSecureHeaders(res: NextApiResponse): void {
+    const helmetMiddleware = helmet({
+        contentSecurityPolicy: {
+            directives: {
+                defaultSrc: ["'self'"],
+                scriptSrc: ["'self'", "'unsafe-inline'"],
+                styleSrc: ["'self'", "'unsafe-inline'"],
+                imgSrc: ["'self'", "data:", "https:"],
+            },
+        },
+        referrerPolicy: {
+            policy: 'strict-origin-when-cross-origin',
+        },
+    })
+
+    // Create a mock request object
+    const mockReq = {} as IncomingMessage
+
+    // Cast NextApiResponse to ServerResponse
+    const nodeRes = res as unknown as ServerResponse
+
+    // Define a named function to handle potential errors
+    const handleHelmetError = (err?: unknown): void => {
+        if (err) {
+            console.error('Helmet middleware error:', err)
+            // You might want to set a default security header if Helmet fails
+            res.setHeader('X-Content-Type-Options', 'nosniff')
+        }
+    }
+
+    // Apply helmet middleware with error handling
+    helmetMiddleware(mockReq, nodeRes, handleHelmetError)
+}
+

package/src/serverMock.ts

@@ -0,0 +1,127 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { MockResponse, MockConfig, ServerComponentMock } from './types'
+
+let serverMockConfig: MockConfig = {}
+let mockBaseUrl = 'https://example.com'
+
+export function configureServerMocks(config: MockConfig, baseUrl?: string): void {
+    serverMockConfig = { ...serverMockConfig, ...config }
+    if (baseUrl) {
+        mockBaseUrl = baseUrl
+    }
+}
+
+export function resetServerMocks(): void {
+    serverMockConfig = {}
+    mockBaseUrl = 'https://example.com'
+}
+
+export async function mockServerAction<TArgs extends unknown[], TReturn>(
+    actionName: string,
+    ...args: TArgs
+): Promise<TReturn> {
+    const mockConfig = serverMockConfig[actionName]
+    if (typeof mockConfig === 'function') {
+        const mockRequest = await createMockNextRequest({
+            method: 'POST',
+            body: JSON.stringify(args),
+        })
+
+        const result = await mockConfig(mockRequest)
+        return result.data as TReturn
+    } else if (mockConfig) {
+        return mockConfig.data as TReturn
+    }
+    throw new Error(`No mock configured for server action: ${actionName}`)
+}
+
+export function createServerComponentMock<TProps>(
+    componentName: string
+): ServerComponentMock<TProps, Promise<NextResponse>> {
+    return async (props: TProps): Promise<NextResponse> => {
+        const mockConfig = serverMockConfig[componentName]
+        if (typeof mockConfig === 'function') {
+            const searchParams = new URLSearchParams(props as Record<string, string>)
+            const mockRequest = await createMockNextRequest({
+                method: 'GET',
+                url: `${mockBaseUrl}?${searchParams.toString()}`
+            })
+
+            const mockResponse = await mockConfig(mockRequest)
+            return createMockNextResponse(mockResponse)
+        } else if (mockConfig) {
+            return createMockNextResponse(mockConfig as MockResponse)
+        }
+        throw new Error(`No mock configured for server component: ${componentName}`)
+    }
+}
+
+async function createMockNextRequest(options: {
+    method?: string;
+    url?: string;
+    headers?: HeadersInit;
+    body?: BodyInit;
+}): Promise<NextRequest> {
+    const url = options.url || mockBaseUrl
+
+    const init: RequestInit = {
+        method: options.method || 'GET',
+        headers: options.headers,
+        body: options.body,
+    }
+
+    const request = new Request(url, init)
+    const nextRequest = new NextRequest(request)
+
+    Object.defineProperties(nextRequest, {
+        geo: {
+            value: {
+                city: 'Mock City',
+                country: 'Mock Country',
+                region: 'Mock Region',
+                latitude: '0',
+                longitude: '0'
+            },
+            writable: true
+        },
+        ip: {
+            value: '127.0.0.1',
+            writable: true
+        }
+    })
+
+    return nextRequest
+}
+
+function createMockNextResponse(mockResponse: MockResponse): NextResponse {
+    const { data, status = 200, headers = {} } = mockResponse
+
+    const bodyContent = typeof data === 'string' ? data : JSON.stringify(data)
+
+    const stream = new ReadableStream({
+        start(controller) {
+            controller.enqueue(new TextEncoder().encode(bodyContent))
+            controller.close()
+        }
+    })
+
+    const response = new Response(stream, {
+        status,
+        headers: new Headers(headers)
+    })
+
+    return new NextResponse(response.body, {
+        status,
+        headers: new Headers(headers),
+        url: mockBaseUrl
+    })
+}
+
+export interface TypedMockResponse<T> extends MockResponse {
+    data: T
+}
+
+export function createTypedMock<T>(response: TypedMockResponse<T>): TypedMockResponse<T> {
+    return response
+}
+

package/src/types.ts

@@ -0,0 +1,44 @@
+import { NextApiRequest, NextApiResponse } from 'next'
+import { NextRequest, NextResponse } from 'next/server'
+
+export type MockResponse<T = unknown> = {
+    status: number
+    data: T
+    delay?: number
+    headers?: Record<string, string>
+}
+
+export type MockFunction = (req: NextApiRequest | NextRequest) => MockResponse<unknown> | Promise<MockResponse<unknown>>
+
+export type MockConfig = {
+    [key: string]: MockResponse<unknown> | MockFunction
+}
+
+export type RequestLogger = (req: NextApiRequest, res: NextApiResponse) => void
+
+export type MockInterceptor = (req: NextApiRequest | NextRequest, mockResponse: MockResponse<unknown>) => MockResponse<unknown> | Promise<MockResponse<unknown>>
+
+export type ServerActionMock<TArgs extends unknown[], TReturn> = (...args: TArgs) => TReturn
+
+export type ServerComponentMock<TProps, TReturn = Promise<NextResponse>> = (props: TProps) => TReturn
+
+export type MockOptions = {
+    enableLogging: boolean
+    cacheTimeout: number
+    defaultDelay: number
+    errorRate: number
+}
+
+export type MiddlewareFunction = (req: NextApiRequest, res: NextApiResponse) => Promise<void>
+
+export type Plugin = {
+    name: string
+    initialize: (config: MockConfig) => void
+    beforeRequest?: (req: NextApiRequest | NextRequest) => void
+    afterResponse?: (req: NextApiRequest | NextRequest, response: MockResponse<unknown>) => void
+    errorHandler?: (error: Error, req: NextApiRequest | NextRequest) => MockResponse<unknown>
+    transformResponse?: (response: MockResponse<unknown>) => MockResponse<unknown>
+    validateConfig?: (config: MockConfig) => boolean
+    cleanup?: () => void
+}
+

package/src/validation.ts

@@ -0,0 +1,19 @@
+import * as Joi from 'joi'
+import { NextApiRequest, NextApiResponse } from 'next'
+
+/**
+ * Creates a request validator middleware using the provided Joi schema.
+ * @param schema The Joi schema to validate against.
+ * @returns A middleware function that validates incoming requests.
+ */
+export function createRequestValidator(schema: Joi.ObjectSchema) {
+    return (req: NextApiRequest, res: NextApiResponse, next: () => void) => {
+        const { error } = schema.validate(req.body)
+        if (error) {
+            res.status(400).json({ error: 'Invalid request', details: error.details })
+        } else {
+            next()
+        }
+    }
+}
+

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}
+