next-api-mock 1.0.0 → 1.0.1

package/src/middleware.ts

@@ -1,14 +1,32 @@
-import { NextApiRequest } from 'next'
-import { MockResponse, MockInterceptor } from './types'
+import { AnyRequest, AnyResponse, MockResponse, MockInterceptor, MiddlewareFunction } from './types'
 
 export async function applyMiddleware(
-    req: NextApiRequest,
-    response: MockResponse,
+    req: AnyRequest,
+    mockResponse: MockResponse<unknown>,
     interceptor: MockInterceptor | null
-): Promise<MockResponse> {
+): Promise<MockResponse<unknown>> {
     if (interceptor) {
-        return await interceptor(req, response)
+        return await interceptor(req, mockResponse)
     }
-    return response
+    return mockResponse
 }
 
+export function createMiddleware(fn: MiddlewareFunction): MiddlewareFunction {
+    return async (req: AnyRequest, res: AnyResponse) => {
+        await fn(req, res)
+    }
+}
+
+export const corsMiddleware = createMiddleware(async (req: AnyRequest, res: AnyResponse) => {
+    if ('setHeader' in res) {
+        res.setHeader('Access-Control-Allow-Origin', '*')
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS')
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization')
+    }
+})
+
+export const loggingMiddleware = createMiddleware(async (req: AnyRequest, res: AnyResponse) => {
+    console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`)
+})
+
+

package/src/monitoring.ts

@@ -1,6 +1,7 @@
 import * as prometheus from 'prom-client'
 import { NextApiRequest, NextApiResponse } from 'next'
-import { MockResponse } from './types'
+import { NextResponse } from 'next/server'
+import { AnyRequest, AnyResponse, MockResponse } from './types'
 
 const requestCounter = new prometheus.Counter({
     name: 'mock_requests_total',
@@ -20,21 +21,31 @@ const responseTimeHistogram = new prometheus.Histogram({
  * @param res The outgoing response.
  * @param mockResponse The mock response.
  */
-export function collectMetrics(req: NextApiRequest, res: NextApiResponse, mockResponse: MockResponse): void {
+export function collectMetrics(req: AnyRequest, res: AnyResponse, mockResponse: MockResponse): void {
     const labels = {
         method: req.method || 'UNKNOWN',
-        path: req.url || 'UNKNOWN',
-        status: mockResponse.status.toString(),
+        path: 'url' in req ? req.url : (req as NextApiRequest).url || 'UNKNOWN',
+        status: (mockResponse.status || 200).toString(),
     }
 
     requestCounter.inc(labels)
 
     const responseTime = process.hrtime()
-    res.on('finish', () => {
+
+    if ('on' in res) {
+        // NextApiResponse
+        (res as NextApiResponse).on('finish', () => {
+            const [seconds, nanoseconds] = process.hrtime(responseTime)
+            const duration = seconds + nanoseconds / 1e9
+            responseTimeHistogram.observe({ method: labels.method, path: labels.path }, duration)
+        })
+    } else {
+        // NextResponse
+        // For NextResponse, we can't hook into 'finish' event, so we'll record the time immediately
         const [seconds, nanoseconds] = process.hrtime(responseTime)
         const duration = seconds + nanoseconds / 1e9
         responseTimeHistogram.observe({ method: labels.method, path: labels.path }, duration)
-    })
+    }
 }
 
 /**
@@ -43,5 +54,4 @@ export function collectMetrics(req: NextApiRequest, res: NextApiResponse, mockRe
  */
 export async function reportMetrics(): Promise<string> {
     return await prometheus.register.metrics()
-}
-
+}

package/src/serverMock.ts

@@ -1,5 +1,6 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { MockResponse, MockConfig, ServerComponentMock } from './types'
+import { MockResponse, MockConfig, ServerComponentMock, NextRequestType, NextResponseType, AnyRequest } from './types'
+import { isAppRouter, hasServerActions } from './utils/versionCheck'
 
 let serverMockConfig: MockConfig = {}
 let mockBaseUrl = 'https://example.com'
@@ -20,6 +21,10 @@ export async function mockServerAction<TArgs extends unknown[], TReturn>(
     actionName: string,
     ...args: TArgs
 ): Promise<TReturn> {
+    if (!hasServerActions) {
+        throw new Error('Server Actions are not supported in this Next.js version')
+    }
+
     const mockConfig = serverMockConfig[actionName]
     if (typeof mockConfig === 'function') {
         const mockRequest = await createMockNextRequest({
@@ -37,8 +42,12 @@ export async function mockServerAction<TArgs extends unknown[], TReturn>(
 
 export function createServerComponentMock<TProps>(
     componentName: string
-): ServerComponentMock<TProps, Promise<NextResponse>> {
-    return async (props: TProps): Promise<NextResponse> => {
+): ServerComponentMock<TProps, Promise<NextResponseType>> {
+    if (!isAppRouter) {
+        throw new Error('Server Components are not supported in this Next.js version')
+    }
+
+    return async (props: TProps): Promise<NextResponseType> => {
         const mockConfig = serverMockConfig[componentName]
         if (typeof mockConfig === 'function') {
             const searchParams = new URLSearchParams(props as Record<string, string>)
@@ -61,7 +70,7 @@ async function createMockNextRequest(options: {
     url?: string;
     headers?: HeadersInit;
     body?: BodyInit;
-}): Promise<NextRequest> {
+}): Promise<NextRequestType> {
     const url = options.url || mockBaseUrl
 
     const init: RequestInit = {
@@ -93,27 +102,12 @@ async function createMockNextRequest(options: {
     return nextRequest
 }
 
-function createMockNextResponse(mockResponse: MockResponse): NextResponse {
+function createMockNextResponse(mockResponse: MockResponse): NextResponseType {
     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, {
+    return NextResponse.json(data, {
         status,
         headers: new Headers(headers),
-        url: mockBaseUrl
     })
 }
 

package/src/types.ts

@@ -1,44 +1,54 @@
-import { NextApiRequest, NextApiResponse } from 'next'
-import { NextRequest, NextResponse } from 'next/server'
+import type { NextApiRequest, NextApiResponse } from 'next'
+import type { NextRequest, NextResponse } from 'next/server'
 
-export type MockResponse<T = unknown> = {
-    status: number
+export type AnyRequest = NextApiRequest | NextRequest
+export type AnyResponse = NextApiResponse | NextResponse
+
+export interface MockResponse<T = unknown> {
+    status?: number
     data: T
-    delay?: number
     headers?: Record<string, string>
+    delay?: number
 }
 
-export type MockFunction = (req: NextApiRequest | NextRequest) => MockResponse<unknown> | Promise<MockResponse<unknown>>
+export type MockFunction = (req: AnyRequest) => Promise<MockResponse>
 
-export type MockConfig = {
-    [key: string]: MockResponse<unknown> | MockFunction
+export interface MockConfig {
+    [path: string]: MockResponse | MockFunction
 }
 
-export type RequestLogger = (req: NextApiRequest, res: NextApiResponse) => void
+export type RequestLogger = (req: AnyRequest, res: AnyResponse) => void
 
-export type MockInterceptor = (req: NextApiRequest | NextRequest, mockResponse: MockResponse<unknown>) => MockResponse<unknown> | Promise<MockResponse<unknown>>
+export type MockInterceptor = (req: AnyRequest, mockResponse: MockResponse) => Promise<MockResponse>
 
-export type ServerActionMock<TArgs extends unknown[], TReturn> = (...args: TArgs) => TReturn
-
-export type ServerComponentMock<TProps, TReturn = Promise<NextResponse>> = (props: TProps) => TReturn
-
-export type MockOptions = {
+export interface MockOptions {
     enableLogging: boolean
     cacheTimeout: number
     defaultDelay: number
     errorRate: number
 }
 
-export type MiddlewareFunction = (req: NextApiRequest, res: NextApiResponse) => Promise<void>
+export type MiddlewareFunction = (req: AnyRequest, res: AnyResponse) => Promise<void>
+
+export interface RateLimitOptions {
+    windowMs: number
+    max: number
+}
 
-export type Plugin = {
+export interface 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
 }
 
+export function isNextApiRequest(req: AnyRequest): req is NextApiRequest {
+    return 'query' in req && 'body' in req && !('nextUrl' in req)
+}
+
+export function isNextRequest(req: AnyRequest): req is NextRequest {
+    return 'nextUrl' in req && 'geo' in req
+}
+
+export type NextRequestType = NextRequest
+export type NextResponseType = NextResponse
+
+export type ServerComponentMock<TProps, TReturn> = (props: TProps) => TReturn

package/src/utils/versionCheck.ts

@@ -0,0 +1,20 @@
+import semver from 'semver'
+import { version as nextVersion } from 'next/package.json'
+
+const coercedVersion = semver.coerce(nextVersion)
+
+if (!coercedVersion) {
+    throw new Error('Unable to determine Next.js version')
+}
+
+export const isNextJs12 = semver.satisfies(coercedVersion, '12.x')
+export const isNextJs13 = semver.satisfies(coercedVersion, '13.x')
+export const isNextJs14 = semver.satisfies(coercedVersion, '14.x')
+export const isNextJs15 = semver.satisfies(coercedVersion, '15.x')
+
+export const isAppRouter = semver.gte(coercedVersion, '13.0.0')
+export const hasServerActions = semver.gte(coercedVersion, '13.4.0')
+
+export function getNextVersion(): string {
+    return nextVersion
+}