@schmock/core 1.9.0 → 1.9.2

package/src/builder.ts

@@ -1,8 +1,8 @@
 import type { Server } from "node:http";
 import { createServer } from "node:http";
-import { isStatusTuple, toHttpMethod } from "./constants.js";
+import { normalizePath, toHttpMethod } from "./constants.js";
 import {
-  PluginError,
+  errorMessage,
   RouteDefinitionError,
   RouteNotFoundError,
   SchmockError,
@@ -14,10 +14,14 @@ import {
   writeSchmockResponse,
 } from "./http-helpers.js";
 import { parseRouteKey } from "./parser.js";
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : "Unknown error";
-}
+import { runPluginPipeline } from "./plugin-pipeline.js";
+import { parseResponse } from "./response-parser.js";
+import type { CompiledCallableRoute } from "./route-matcher.js";
+import {
+  extractParams,
+  findRoute,
+  isGeneratorFunction,
+} from "./route-matcher.js";
 
 /**
  * Debug logger that respects debug mode configuration
@@ -49,37 +53,6 @@ class DebugLogger {
   }
 }
 
-/**
- * Compiled callable route with pattern matching
- */
-interface CompiledCallableRoute {
-  pattern: RegExp;
-  params: string[];
-  method: Schmock.HttpMethod;
-  path: string;
-  generator: Schmock.Generator;
-  config: Schmock.RouteConfig;
-}
-
-function isGeneratorFunction(
-  gen: Schmock.Generator,
-): gen is Schmock.GeneratorFunction {
-  return typeof gen === "function";
-}
-
-function isResponseObject(value: unknown): value is {
-  status: number;
-  body: unknown;
-  headers?: Record<string, string>;
-} {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "status" in value &&
-    "body" in value
-  );
-}
-
 /**
  * Callable mock instance that implements the new API.
  *
@@ -180,11 +153,7 @@ export class CallableMockInstance {
     // Store static routes (no params) in Map for O(1) lookup
     // Only store the first registration — "first registration wins" semantics
     if (parsed.params.length === 0) {
-      const normalizedPath =
-        parsed.path.endsWith("/") && parsed.path !== "/"
-          ? parsed.path.slice(0, -1)
-          : parsed.path;
-      const key = `${parsed.method} ${normalizedPath}`;
+      const key = `${parsed.method} ${normalizePath(parsed.path)}`;
       if (!this.staticRoutes.has(key)) {
         this.staticRoutes.set(key, compiledRoute);
       }
@@ -224,27 +193,27 @@ export class CallableMockInstance {
   // ===== Request Spy / History API =====
 
   history(method?: Schmock.HttpMethod, path?: string): Schmock.RequestRecord[] {
-    if (method && path) {
+    if (method || path) {
       return this.requestHistory.filter(
-        (r) => r.method === method && r.path === path,
+        (r) => (!method || r.method === method) && (!path || r.path === path),
       );
     }
     return [...this.requestHistory];
   }
 
   called(method?: Schmock.HttpMethod, path?: string): boolean {
-    if (method && path) {
+    if (method || path) {
       return this.requestHistory.some(
-        (r) => r.method === method && r.path === path,
+        (r) => (!method || r.method === method) && (!path || r.path === path),
       );
     }
     return this.requestHistory.length > 0;
   }
 
   callCount(method?: Schmock.HttpMethod, path?: string): number {
-    if (method && path) {
+    if (method || path) {
       return this.requestHistory.filter(
-        (r) => r.method === method && r.path === path,
+        (r) => (!method || r.method === method) && (!path || r.path === path),
       ).length;
     }
     return this.requestHistory.length;
@@ -254,9 +223,9 @@ export class CallableMockInstance {
     method?: Schmock.HttpMethod,
     path?: string,
   ): Schmock.RequestRecord | undefined {
-    if (method && path) {
+    if (method || path) {
       const filtered = this.requestHistory.filter(
-        (r) => r.method === method && r.path === path,
+        (r) => (!method || r.method === method) && (!path || r.path === path),
       );
       return filtered[filtered.length - 1];
     }
@@ -274,7 +243,7 @@ export class CallableMockInstance {
   }
 
   getState(): Record<string, unknown> {
-    return this.globalConfig.state || {};
+    return { ...(this.globalConfig.state || {}) };
   }
 
   // ===== Lifecycle Events =====
@@ -351,19 +320,33 @@ export class CallableMockInstance {
     }
 
     const httpServer = createServer((req, res) => {
-      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-      const method = toHttpMethod(req.method ?? "GET");
-      const path = url.pathname;
-      const headers = parseNodeHeaders(req);
-      const query = parseNodeQuery(url);
-
-      void collectBody(req, headers).then((body) =>
-        this.handle(method, path, { headers, body, query }).then(
-          (schmockResponse) => {
-            writeSchmockResponse(res, schmockResponse);
-          },
-        ),
-      );
+      const handleRequest = async () => {
+        const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+        const method = toHttpMethod(req.method ?? "GET");
+        const path = url.pathname;
+        const headers = parseNodeHeaders(req);
+        const query = parseNodeQuery(url);
+        const body = await collectBody(req, headers);
+        const schmockResponse = await this.handle(method, path, {
+          headers,
+          body,
+          query,
+        });
+        writeSchmockResponse(res, schmockResponse);
+      };
+
+      handleRequest().catch((error) => {
+        if (!res.headersSent) {
+          res.writeHead(500, { "content-type": "application/json" });
+        }
+        res.end(
+          JSON.stringify({
+            error:
+              error instanceof Error ? error.message : "Internal Server Error",
+            code: "SERVER_ERROR",
+          }),
+        );
+      });
     });
 
     this.server = httpServer;
@@ -396,11 +379,13 @@ export class CallableMockInstance {
     path: string,
     options?: Schmock.RequestOptions,
   ): Promise<Schmock.Response> {
-    const requestId = crypto.randomUUID();
     const handleStart = performance.now();
+    const requestId = this.globalConfig.debug ? crypto.randomUUID() : "";
+    const reqQuery = options?.query || {};
+    const reqHeaders = options?.headers || {};
     this.logger.log("request", `[${requestId}] ${method} ${path}`, {
-      headers: options?.headers,
-      query: options?.query,
+      headers: reqHeaders,
+      query: reqQuery,
       bodyType: options?.body ? typeof options.body : "none",
     });
     this.logger.time(`request-${requestId}`);
@@ -408,7 +393,7 @@ export class CallableMockInstance {
     this.emit("request:start", {
       method,
       path,
-      headers: options?.headers || {},
+      headers: reqHeaders,
     });
 
     try {
@@ -441,6 +426,12 @@ export class CallableMockInstance {
             body: { error: error.message, code: error.code },
             headers: {},
           };
+          this.emit("request:end", {
+            method,
+            path,
+            status: 404,
+            duration: performance.now() - handleStart,
+          });
           this.logger.timeEnd(`request-${requestId}`);
           return response;
         }
@@ -451,7 +442,12 @@ export class CallableMockInstance {
       }
 
       // Find matching route
-      const matchedRoute = this.findRoute(method, requestPath);
+      const matchedRoute = findRoute(
+        method,
+        requestPath,
+        this.staticRoutes,
+        this.routes,
+      );
 
       if (!matchedRoute) {
         this.logger.log(
@@ -481,7 +477,7 @@ export class CallableMockInstance {
       );
 
       // Extract parameters from the matched route
-      const params = this.extractParams(matchedRoute, requestPath);
+      const params = extractParams(matchedRoute, requestPath);
 
       this.emit("request:match", {
         method,
@@ -495,8 +491,8 @@ export class CallableMockInstance {
         method,
         path: requestPath,
         params,
-        query: options?.query || {},
-        headers: options?.headers || {},
+        query: reqQuery,
+        headers: reqHeaders,
         body: options?.body,
         state: this.globalConfig.state || {},
       };
@@ -514,8 +510,8 @@ export class CallableMockInstance {
         route: matchedRoute.config,
         method,
         params,
-        query: options?.query || {},
-        headers: options?.headers || {},
+        query: reqQuery,
+        headers: reqHeaders,
         body: options?.body,
         state: new Map(),
         routeState: this.globalConfig.state || {},
@@ -523,11 +519,11 @@ export class CallableMockInstance {
 
       // Run plugin pipeline to transform the response
       try {
-        const pipelineResult = await this.runPluginPipeline(
+        const pipelineResult = await runPluginPipeline(
+          this.plugins,
           pluginContext,
           result,
-          matchedRoute.config,
-          requestId,
+          this.logger,
         );
         pluginContext = pipelineResult.context;
         result = pipelineResult.response;
@@ -540,7 +536,7 @@ export class CallableMockInstance {
       }
 
       // Parse and prepare response
-      const response = this.parseResponse(result, matchedRoute.config);
+      const response = parseResponse(result, matchedRoute.config);
 
       // Apply delay (route-level overrides global)
       await this.applyDelay(matchedRoute.config.delay);
@@ -550,8 +546,8 @@ export class CallableMockInstance {
         method,
         path: requestPath,
         params,
-        query: options?.query || {},
-        headers: options?.headers || {},
+        query: reqQuery,
+        headers: reqHeaders,
         body: options?.body,
         timestamp: Date.now(),
         response: { status: response.status, body: response.body },
@@ -597,6 +593,13 @@ export class CallableMockInstance {
       // Apply delay even for error responses
       await this.applyDelay();
 
+      this.emit("request:end", {
+        method,
+        path,
+        status: 500,
+        duration: performance.now() - handleStart,
+      });
+
       this.logger.log("error", `[${requestId}] Returning error response 500`);
       this.logger.timeEnd(`request-${requestId}`);
       return errorResponse;
@@ -623,238 +626,4 @@ export class CallableMockInstance {
 
     await new Promise((resolve) => setTimeout(resolve, ms));
   }
-
-  /**
-   * Parse and normalize response result into Response object
-   * Handles tuple format [status, body, headers], direct values, and response objects
-   * @param result - Raw result from generator or plugin
-   * @param routeConfig - Route configuration for content-type defaults
-   * @returns Normalized Response object with status, body, and headers
-   * @private
-   */
-  private parseResponse(
-    result: unknown,
-    routeConfig: Schmock.RouteConfig,
-  ): Schmock.Response {
-    let status = 200;
-    let body: unknown = result;
-    let headers: Record<string, string> = {};
-
-    let tupleFormat = false;
-
-    // Handle already-formed response objects (from plugin error recovery)
-    if (isResponseObject(result)) {
-      return {
-        status: result.status,
-        body: result.body,
-        headers: result.headers || {},
-      };
-    }
-
-    // Handle tuple response format [status, body, headers?]
-    if (isStatusTuple(result)) {
-      [status, body, headers = {}] = result;
-      tupleFormat = true;
-    }
-
-    // Handle null/undefined responses with 204 No Content
-    // But don't auto-convert if tuple format was used (status was explicitly provided)
-    if (body === null || body === undefined) {
-      if (!tupleFormat) {
-        status = status === 200 ? 204 : status; // Only change to 204 if status wasn't explicitly set via tuple
-      }
-      body = undefined; // Ensure body is undefined for null responses
-    }
-
-    // Add content-type header from route config if it exists and headers don't already have it
-    // But only if this isn't a tuple response (where headers are explicitly controlled)
-    if (!headers["content-type"] && routeConfig.contentType && !tupleFormat) {
-      headers["content-type"] = routeConfig.contentType;
-
-      // Handle special conversion cases when contentType is explicitly set
-      if (routeConfig.contentType === "text/plain" && body !== undefined) {
-        if (typeof body === "object" && !Buffer.isBuffer(body)) {
-          body = JSON.stringify(body);
-        } else if (typeof body !== "string") {
-          body = String(body);
-        }
-      }
-    }
-
-    return {
-      status,
-      body,
-      headers,
-    };
-  }
-
-  /**
-   * Run all registered plugins in sequence
-   * First plugin to set response becomes generator, subsequent plugins transform
-   * Handles plugin errors via onError hooks
-   * @param context - Plugin context with request details
-   * @param initialResponse - Initial response from route generator
-   * @param _routeConfig - Route config (unused but kept for signature)
-   * @param _requestId - Request ID (unused but kept for signature)
-   * @returns Updated context and final response after all plugins
-   * @private
-   */
-  private async runPluginPipeline(
-    context: Schmock.PluginContext,
-    initialResponse?: unknown,
-    _routeConfig?: Schmock.RouteConfig,
-    _requestId?: string,
-  ): Promise<{ context: Schmock.PluginContext; response?: unknown }> {
-    let currentContext = context;
-    let response: unknown = initialResponse;
-
-    this.logger.log(
-      "pipeline",
-      `Running plugin pipeline for ${this.plugins.length} plugins`,
-    );
-
-    for (const plugin of this.plugins) {
-      this.logger.log("pipeline", `Processing plugin: ${plugin.name}`);
-
-      try {
-        const result = await plugin.process(currentContext, response);
-
-        if (!result || !result.context) {
-          throw new Error(`Plugin ${plugin.name} didn't return valid result`);
-        }
-
-        currentContext = result.context;
-
-        // First plugin to set response becomes the generator
-        if (
-          result.response !== undefined &&
-          (response === undefined || response === null)
-        ) {
-          this.logger.log(
-            "pipeline",
-            `Plugin ${plugin.name} generated response`,
-          );
-          response = result.response;
-        } else if (result.response !== undefined && response !== undefined) {
-          this.logger.log(
-            "pipeline",
-            `Plugin ${plugin.name} transformed response`,
-          );
-          response = result.response;
-        }
-      } catch (error) {
-        this.logger.log(
-          "pipeline",
-          `Plugin ${plugin.name} failed: ${errorMessage(error)}`,
-        );
-
-        // Try error handling if plugin has onError hook
-        if (plugin.onError) {
-          try {
-            const pluginError =
-              error instanceof Error ? error : new Error(errorMessage(error));
-            const errorResult = await plugin.onError(
-              pluginError,
-              currentContext,
-            );
-            if (errorResult) {
-              this.logger.log(
-                "pipeline",
-                `Plugin ${plugin.name} handled error`,
-              );
-
-              // Error return → transform the thrown error
-              if (errorResult instanceof Error) {
-                throw new PluginError(plugin.name, errorResult);
-              }
-
-              // ResponseResult return → recover, stop pipeline
-              if (
-                typeof errorResult === "object" &&
-                errorResult !== null &&
-                "status" in errorResult
-              ) {
-                response = errorResult;
-                break;
-              }
-            }
-            // void/falsy return → propagate original error below
-          } catch (hookError) {
-            // If the hook itself threw (including our PluginError above), re-throw it
-            if (hookError instanceof PluginError) {
-              throw hookError;
-            }
-            this.logger.log(
-              "pipeline",
-              `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`,
-            );
-          }
-        }
-
-        const cause =
-          error instanceof Error ? error : new Error(errorMessage(error));
-        throw new PluginError(plugin.name, cause);
-      }
-    }
-
-    return { context: currentContext, response };
-  }
-
-  /**
-   * Find a route that matches the given method and path
-   * Uses two-pass matching: static routes first, then parameterized routes
-   * Matches routes in registration order (first registered wins)
-   * @param method - HTTP method to match
-   * @param path - Request path to match
-   * @returns Matched compiled route or undefined if no match
-   * @private
-   */
-  private findRoute(
-    method: Schmock.HttpMethod,
-    path: string,
-  ): CompiledCallableRoute | undefined {
-    // O(1) lookup for static routes
-    const normalizedPath =
-      path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-    const staticMatch = this.staticRoutes.get(`${method} ${normalizedPath}`);
-    if (staticMatch) {
-      return staticMatch;
-    }
-
-    // Fall through to parameterized route scan
-    for (const route of this.routes) {
-      if (
-        route.method === method &&
-        route.params.length > 0 &&
-        route.pattern.test(path)
-      ) {
-        return route;
-      }
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Extract parameter values from path based on route pattern
-   * Maps capture groups from regex match to parameter names
-   * @param route - Compiled route with pattern and param names
-   * @param path - Request path to extract values from
-   * @returns Object mapping parameter names to extracted values
-   * @private
-   */
-  private extractParams(
-    route: CompiledCallableRoute,
-    path: string,
-  ): Record<string, string> {
-    const match = path.match(route.pattern);
-    if (!match) return {};
-
-    const params: Record<string, string> = {};
-    route.params.forEach((param, index) => {
-      params[param] = match[index + 1];
-    });
-
-    return params;
-  }
 }

package/src/constants.ts

@@ -24,6 +24,15 @@ export function toHttpMethod(method: string): HttpMethod {
   return upper;
 }
 
+export function normalizePath(path: string): string {
+  return path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+}
+
+export function toRouteKey(method: HttpMethod, path: string): Schmock.RouteKey {
+  const key: `${HttpMethod} ${string}` = `${method} ${path}`;
+  return key;
+}
+
 /**
  * Check if a value is a status tuple: [status, body] or [status, body, headers]
  * Guards against misinterpreting numeric arrays like [1, 2, 3] as tuples.

package/src/errors.ts

@@ -1,3 +1,7 @@
+export function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+
 /**
  * Base error class for all Schmock errors
  */

package/src/http-helpers.ts

@@ -25,18 +25,40 @@ export function parseNodeQuery(url: URL): Record<string, string> {
   return query;
 }
 
+/** Default body size limit: 10 MB */
+const DEFAULT_MAX_BODY_SIZE = 10 * 1024 * 1024;
+
 /**
  * Collect and parse the request body from a Node.js IncomingMessage.
  * Returns parsed JSON if content-type includes "json", otherwise the raw string.
  * Returns undefined for empty bodies.
+ * @param req - Node.js IncomingMessage
+ * @param headers - Parsed request headers
+ * @param maxBodySize - Maximum body size in bytes (default: 10 MB)
  */
 export function collectBody(
   req: IncomingMessage,
   headers: Record<string, string>,
+  maxBodySize = DEFAULT_MAX_BODY_SIZE,
 ): Promise<unknown> {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     const chunks: Buffer[] = [];
-    req.on("data", (chunk: Buffer) => chunks.push(chunk));
+    let totalSize = 0;
+
+    req.on("error", reject);
+
+    req.on("data", (chunk: Buffer) => {
+      totalSize += chunk.length;
+      if (totalSize > maxBodySize) {
+        req.destroy();
+        reject(
+          Object.assign(new Error("Request body too large"), { status: 413 }),
+        );
+        return;
+      }
+      chunks.push(chunk);
+    });
+
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString();
       if (!raw) {

package/src/index.ts

@@ -85,6 +85,7 @@ export {
   isStatusTuple,
   ROUTE_NOT_FOUND_CODE,
   toHttpMethod,
+  toRouteKey,
 } from "./constants.js";
 // Re-export errors
 export {