@schmock/core 1.9.0 → 1.9.2

package/src/plugin-pipeline.ts

@@ -0,0 +1,100 @@
+import { errorMessage, PluginError } from "./errors.js";
+
+/** Structural typing — DebugLogger satisfies this without an import */
+interface PipelineLogger {
+  log(category: string, message: string, data?: unknown): void;
+}
+
+/**
+ * Run all registered plugins in sequence
+ * First plugin to set response becomes generator, subsequent plugins transform
+ * Handles plugin errors via onError hooks
+ */
+export async function runPluginPipeline(
+  plugins: Schmock.Plugin[],
+  context: Schmock.PluginContext,
+  initialResponse: unknown,
+  logger: PipelineLogger,
+): Promise<{ context: Schmock.PluginContext; response?: unknown }> {
+  let currentContext = context;
+  let response: unknown = initialResponse;
+
+  logger.log(
+    "pipeline",
+    `Running plugin pipeline for ${plugins.length} plugins`,
+  );
+
+  for (const plugin of plugins) {
+    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)
+      ) {
+        logger.log("pipeline", `Plugin ${plugin.name} generated response`);
+        response = result.response;
+      } else if (result.response !== undefined && response !== undefined) {
+        logger.log("pipeline", `Plugin ${plugin.name} transformed response`);
+        response = result.response;
+      }
+    } catch (error) {
+      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) {
+            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;
+          }
+          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 };
+}

package/src/response-parser.ts

@@ -0,0 +1,74 @@
+import { isStatusTuple } from "./constants.js";
+
+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
+  );
+}
+
+/**
+ * Parse and normalize response result into Response object
+ * Handles tuple format [status, body, headers], direct values, and response objects
+ */
+export function 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,
+  };
+}

package/src/route-matcher.ts

@@ -0,0 +1,69 @@
+import { normalizePath } from "./constants.js";
+
+/**
+ * Compiled callable route with pattern matching
+ */
+export interface CompiledCallableRoute {
+  pattern: RegExp;
+  params: string[];
+  method: Schmock.HttpMethod;
+  path: string;
+  generator: Schmock.Generator;
+  config: Schmock.RouteConfig;
+}
+
+export function isGeneratorFunction(
+  gen: Schmock.Generator,
+): gen is Schmock.GeneratorFunction {
+  return typeof gen === "function";
+}
+
+/**
+ * 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)
+ */
+export function findRoute(
+  method: Schmock.HttpMethod,
+  path: string,
+  staticRoutes: Map<string, CompiledCallableRoute>,
+  routes: CompiledCallableRoute[],
+): CompiledCallableRoute | undefined {
+  // O(1) lookup for static routes
+  const staticMatch = staticRoutes.get(`${method} ${normalizePath(path)}`);
+  if (staticMatch) {
+    return staticMatch;
+  }
+
+  // Fall through to parameterized route scan
+  for (const route of 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
+ */
+export function 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;
+}