@schmock/core 1.9.0 → 1.9.2

package/dist/plugin-pipeline.js

@@ -0,0 +1,66 @@
+import { errorMessage, PluginError } from "./errors.js";
+/**
+ * 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, context, initialResponse, logger) {
+    let currentContext = context;
+    let response = 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/dist/response-parser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parse and normalize response result into Response object
+ * Handles tuple format [status, body, headers], direct values, and response objects
+ */
+export declare function parseResponse(result: unknown, routeConfig: Schmock.RouteConfig): Schmock.Response;
+//# sourceMappingURL=response-parser.d.ts.map

package/dist/response-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-parser.d.ts","sourceRoot":"","sources":["../src/response-parser.ts"],"names":[],"mappings":"AAeA;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,EACf,WAAW,EAAE,OAAO,CAAC,WAAW,GAC/B,OAAO,CAAC,QAAQ,CAmDlB"}

package/dist/response-parser.js

@@ -0,0 +1,57 @@
+import { isStatusTuple } from "./constants.js";
+function isResponseObject(value) {
+    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, routeConfig) {
+    let status = 200;
+    let body = result;
+    let headers = {};
+    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/dist/route-matcher.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 declare function isGeneratorFunction(gen: Schmock.Generator): gen is Schmock.GeneratorFunction;
+/**
+ * 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 declare function findRoute(method: Schmock.HttpMethod, path: string, staticRoutes: Map<string, CompiledCallableRoute>, routes: CompiledCallableRoute[]): CompiledCallableRoute | undefined;
+/**
+ * Extract parameter values from path based on route pattern
+ * Maps capture groups from regex match to parameter names
+ */
+export declare function extractParams(route: CompiledCallableRoute, path: string): Record<string, string>;
+//# sourceMappingURL=route-matcher.d.ts.map

package/dist/route-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-matcher.d.ts","sourceRoot":"","sources":["../src/route-matcher.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC;CAC7B;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,OAAO,CAAC,SAAS,GACrB,GAAG,IAAI,OAAO,CAAC,iBAAiB,CAElC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,EAChD,MAAM,EAAE,qBAAqB,EAAE,GAC9B,qBAAqB,GAAG,SAAS,CAmBnC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,qBAAqB,EAC5B,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUxB"}

package/dist/route-matcher.js

@@ -0,0 +1,39 @@
+import { normalizePath } from "./constants.js";
+export function isGeneratorFunction(gen) {
+    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, path, staticRoutes, routes) {
+    // 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, path) {
+    const match = path.match(route.pattern);
+    if (!match)
+        return {};
+    const params = {};
+    route.params.forEach((param, index) => {
+        params[param] = match[index + 1];
+    });
+    return params;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/core",
   "description": "Core functionality for Schmock",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,7 +33,8 @@
   "license": "MIT",
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^6.2.0",
-    "@types/node": "^25.2.3",
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^25.3.0",
     "@vitest/ui": "^4.0.18",
     "vitest": "^4.0.18"
   }