@schmock/core 1.9.1 → 1.9.4

package/dist/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAuDA;;;;GAIG;AACH,qBAAa,oBAAoB;IAYnB,OAAO,CAAC,YAAY;IAXhC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,WAAW,CAA2C;IAC9D,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,UAAU,CAAiC;IAEnD,OAAO,CAAC,SAAS,CAAoC;gBAEjC,YAAY,GAAE,OAAO,CAAC,YAAiB;IAa3D,WAAW,CACT,KAAK,EAAE,OAAO,CAAC,QAAQ,EACvB,SAAS,EAAE,OAAO,CAAC,SAAS,EAC5B,MAAM,EAAE,OAAO,CAAC,WAAW,GAC1B,IAAI;IAqFP,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,oBAAoB,GAAG,IAAI;IAIvD,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI;IAoBlC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE;IAS5E,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAS3D,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IAS7D,WAAW,CACT,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAC3B,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,GAAG,SAAS;IAYpC,SAAS,IAAI,OAAO,CAAC,SAAS,EAAE;IAQhC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAMnC,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,EAC/B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GACnD,IAAI;IAUP,GAAG,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,EAChC,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GACnD,IAAI;IAKP,OAAO,CAAC,IAAI;IAWZ,KAAK,IAAI,IAAI;IAeb,YAAY,IAAI,IAAI;IAKpB,UAAU,IAAI,IAAI;IAWlB,MAAM,CAAC,IAAI,SAAI,EAAE,QAAQ,SAAc,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;IAuCrE,KAAK,IAAI,IAAI;IAUP,MAAM,CACV,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,GAC/B,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IAqN5B;;;;OAIG;YACW,UAAU;CAezB"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAuDA;;;;GAIG;AACH,qBAAa,oBAAoB;IAYnB,OAAO,CAAC,YAAY;IAXhC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,WAAW,CAA2C;IAC9D,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,UAAU,CAAiC;IAEnD,OAAO,CAAC,SAAS,CAAoC;gBAEjC,YAAY,GAAE,OAAO,CAAC,YAAiB;IAa3D,WAAW,CACT,KAAK,EAAE,OAAO,CAAC,QAAQ,EACvB,SAAS,EAAE,OAAO,CAAC,SAAS,EAC5B,MAAM,EAAE,OAAO,CAAC,WAAW,GAC1B,IAAI;IAiFP,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,oBAAoB,GAAG,IAAI;IAIvD,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI;IAoBlC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE;IAS5E,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAS3D,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IAS7D,WAAW,CACT,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAC3B,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,GAAG,SAAS;IAYpC,SAAS,IAAI,OAAO,CAAC,SAAS,EAAE;IAQhC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAMnC,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,EAC/B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GACnD,IAAI;IAUP,GAAG,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,EAChC,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GACnD,IAAI;IAKP,OAAO,CAAC,IAAI;IAWZ,KAAK,IAAI,IAAI;IAeb,YAAY,IAAI,IAAI;IAKpB,UAAU,IAAI,IAAI;IAWlB,MAAM,CAAC,IAAI,SAAI,EAAE,QAAQ,SAAc,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;IAqDrE,KAAK,IAAI,IAAI;IAUP,MAAM,CACV,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,GAC/B,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IAoO5B;;;;OAIG;YACW,UAAU;CAezB"}

package/dist/builder.js

@@ -1,5 +1,5 @@
 import { createServer } from "node:http";
-import { toHttpMethod } from "./constants.js";
+import { normalizePath, toHttpMethod } from "./constants.js";
 import { errorMessage, RouteDefinitionError, RouteNotFoundError, SchmockError, } from "./errors.js";
 import { collectBody, parseNodeHeaders, parseNodeQuery, writeSchmockResponse, } from "./http-helpers.js";
 import { parseRouteKey } from "./parser.js";
@@ -119,10 +119,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);
             }
@@ -152,26 +149,26 @@ export class CallableMockInstance {
     }
     // ===== Request Spy / History API =====
     history(method, path) {
-        if (method && path) {
-            return this.requestHistory.filter((r) => r.method === method && r.path === path);
+        if (method || path) {
+            return this.requestHistory.filter((r) => (!method || r.method === method) && (!path || r.path === path));
         }
         return [...this.requestHistory];
     }
     called(method, path) {
-        if (method && path) {
-            return this.requestHistory.some((r) => r.method === method && r.path === path);
+        if (method || path) {
+            return this.requestHistory.some((r) => (!method || r.method === method) && (!path || r.path === path));
         }
         return this.requestHistory.length > 0;
     }
     callCount(method, path) {
-        if (method && path) {
-            return this.requestHistory.filter((r) => r.method === method && r.path === path).length;
+        if (method || path) {
+            return this.requestHistory.filter((r) => (!method || r.method === method) && (!path || r.path === path)).length;
         }
         return this.requestHistory.length;
     }
     lastRequest(method, path) {
-        if (method && path) {
-            const filtered = this.requestHistory.filter((r) => r.method === method && r.path === path);
+        if (method || path) {
+            const filtered = this.requestHistory.filter((r) => (!method || r.method === method) && (!path || r.path === path));
             return filtered[filtered.length - 1];
         }
         return this.requestHistory[this.requestHistory.length - 1];
@@ -185,7 +182,7 @@ export class CallableMockInstance {
         }));
     }
     getState() {
-        return this.globalConfig.state || {};
+        return { ...(this.globalConfig.state || {}) };
     }
     // ===== Lifecycle Events =====
     on(event, listener) {
@@ -242,14 +239,29 @@ export class CallableMockInstance {
             throw new SchmockError("Server is already running", "SERVER_ALREADY_RUNNING");
         }
         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) => {
+            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;
         return new Promise((resolve, reject) => {
@@ -273,18 +285,20 @@ export class CallableMockInstance {
         this.logger.log("server", "Server stopped");
     }
     async handle(method, path, options) {
-        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}`);
         this.emit("request:start", {
             method,
             path,
-            headers: options?.headers || {},
+            headers: reqHeaders,
         });
         try {
             // Apply namespace if configured
@@ -307,6 +321,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;
                 }
@@ -348,8 +368,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 || {},
             };
@@ -366,8 +386,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 || {},
@@ -391,8 +411,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 },
@@ -425,6 +445,12 @@ 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;

package/dist/constants.d.ts

@@ -3,6 +3,8 @@ export declare const ROUTE_NOT_FOUND_CODE: "ROUTE_NOT_FOUND";
 export declare const HTTP_METHODS: readonly HttpMethod[];
 export declare function isHttpMethod(method: string): method is HttpMethod;
 export declare function toHttpMethod(method: string): HttpMethod;
+export declare function normalizePath(path: string): string;
+export declare function toRouteKey(method: HttpMethod, path: string): Schmock.RouteKey;
 /**
  * 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/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,oBAAoB,EAAG,iBAA0B,CAAC;AAE/D,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAQpC,CAAC;AAEX,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,UAAU,CAEjE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAMvD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQxE"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,oBAAoB,EAAG,iBAA0B,CAAC;AAE/D,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAQpC,CAAC;AAEX,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,UAAU,CAEjE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAMvD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAG7E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQxE"}

package/dist/constants.js

@@ -18,6 +18,13 @@ export function toHttpMethod(method) {
     }
     return upper;
 }
+export function normalizePath(path) {
+    return path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+}
+export function toRouteKey(method, path) {
+    const key = `${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/dist/http-helpers.d.ts

@@ -12,8 +12,11 @@ export declare function parseNodeQuery(url: URL): Record<string, string>;
  * 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 declare function collectBody(req: IncomingMessage, headers: Record<string, string>): Promise<unknown>;
+export declare function collectBody(req: IncomingMessage, headers: Record<string, string>, maxBodySize?: number): Promise<unknown>;
 /**
  * Write a Schmock Response to a Node.js ServerResponse.
  * Serializes non-string bodies as JSON and sets content-type when missing.

package/dist/http-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-helpers.d.ts","sourceRoot":"","sources":["../src/http-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQ7E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAM/D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,OAAO,CAAC,OAAO,CAAC,CAsBlB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAC1B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACpC,IAAI,CAuBN"}
+{"version":3,"file":"http-helpers.d.ts","sourceRoot":"","sources":["../src/http-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQ7E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAM/D;AAKD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,WAAW,SAAwB,GAClC,OAAO,CAAC,OAAO,CAAC,CAqClB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAC1B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACpC,IAAI,CAuBN"}

package/dist/http-helpers.js

@@ -21,15 +21,30 @@ export function parseNodeQuery(url) {
     });
     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, headers) {
-    return new Promise((resolve) => {
+export function collectBody(req, headers, maxBodySize = DEFAULT_MAX_BODY_SIZE) {
+    return new Promise((resolve, reject) => {
         const chunks = [];
-        req.on("data", (chunk) => chunks.push(chunk));
+        let totalSize = 0;
+        req.on("error", reject);
+        req.on("data", (chunk) => {
+            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/dist/index.d.ts

@@ -22,7 +22,7 @@
  * @returns A callable mock instance
  */
 export declare function schmock(config?: Schmock.GlobalConfig): Schmock.CallableMockInstance;
-export { HTTP_METHODS, isHttpMethod, isStatusTuple, ROUTE_NOT_FOUND_CODE, toHttpMethod, } from "./constants.js";
+export { HTTP_METHODS, isHttpMethod, isStatusTuple, ROUTE_NOT_FOUND_CODE, toHttpMethod, toRouteKey, } from "./constants.js";
 export { PluginError, ResourceLimitError, ResponseGenerationError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors.js";
 export { collectBody, parseNodeHeaders, parseNodeQuery, writeSchmockResponse, } from "./http-helpers.js";
 export type { CallableMockInstance, Generator, GeneratorFunction, GlobalConfig, HttpMethod, Plugin, PluginContext, PluginResult, RequestContext, RequestOptions, RequestRecord, Response, ResponseBody, ResponseResult, RouteConfig, RouteInfo, RouteKey, ServerInfo, StaticData, } from "./types.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CACrB,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,GAC5B,OAAO,CAAC,oBAAoB,CAmD9B;AAGD,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,YAAY,GACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,EACd,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,WAAW,EACX,SAAS,EACT,QAAQ,EACR,UAAU,EACV,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CACrB,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,GAC5B,OAAO,CAAC,oBAAoB,CAmD9B;AAGD,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,UAAU,GACX,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,EACd,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,WAAW,EACX,SAAS,EACT,QAAQ,EACR,UAAU,EACV,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -59,7 +59,7 @@ export function schmock(config) {
     return callableInstance;
 }
 // Re-export constants and utilities
-export { HTTP_METHODS, isHttpMethod, isStatusTuple, ROUTE_NOT_FOUND_CODE, toHttpMethod, } from "./constants.js";
+export { HTTP_METHODS, isHttpMethod, isStatusTuple, ROUTE_NOT_FOUND_CODE, toHttpMethod, toRouteKey, } from "./constants.js";
 // Re-export errors
 export { PluginError, ResourceLimitError, ResponseGenerationError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors.js";
 // Re-export HTTP server helpers

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

@@ -1 +1 @@
-{"version":3,"file":"route-matcher.d.ts","sourceRoot":"","sources":["../src/route-matcher.ts"],"names":[],"mappings":"AAAA;;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,CAqBnC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,qBAAqB,EAC5B,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUxB"}
+{"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

@@ -1,3 +1,4 @@
+import { normalizePath } from "./constants.js";
 export function isGeneratorFunction(gen) {
     return typeof gen === "function";
 }
@@ -8,8 +9,7 @@ export function isGeneratorFunction(gen) {
  */
 export function findRoute(method, path, staticRoutes, routes) {
     // O(1) lookup for static routes
-    const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-    const staticMatch = staticRoutes.get(`${method} ${normalizedPath}`);
+    const staticMatch = staticRoutes.get(`${method} ${normalizePath(path)}`);
     if (staticMatch) {
         return staticMatch;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/core",
   "description": "Core functionality for Schmock",
-  "version": "1.9.1",
+  "version": "1.9.4",
   "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"
   }

package/src/builder.ts

@@ -1,6 +1,6 @@
 import type { Server } from "node:http";
 import { createServer } from "node:http";
-import { toHttpMethod } from "./constants.js";
+import { normalizePath, toHttpMethod } from "./constants.js";
 import {
   errorMessage,
   RouteDefinitionError,
@@ -153,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);
       }
@@ -197,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;
@@ -227,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];
     }
@@ -247,7 +243,7 @@ export class CallableMockInstance {
   }
 
   getState(): Record<string, unknown> {
-    return this.globalConfig.state || {};
+    return { ...(this.globalConfig.state || {}) };
   }
 
   // ===== Lifecycle Events =====
@@ -324,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;
@@ -369,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}`);
@@ -381,7 +393,7 @@ export class CallableMockInstance {
     this.emit("request:start", {
       method,
       path,
-      headers: options?.headers || {},
+      headers: reqHeaders,
     });
 
     try {
@@ -414,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;
         }
@@ -473,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 || {},
       };
@@ -492,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 || {},
@@ -528,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 },
@@ -575,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;

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/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 {

package/src/route-matcher.ts

@@ -1,3 +1,5 @@
+import { normalizePath } from "./constants.js";
+
 /**
  * Compiled callable route with pattern matching
  */
@@ -28,9 +30,7 @@ export function findRoute(
   routes: CompiledCallableRoute[],
 ): CompiledCallableRoute | undefined {
   // O(1) lookup for static routes
-  const normalizedPath =
-    path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-  const staticMatch = staticRoutes.get(`${method} ${normalizedPath}`);
+  const staticMatch = staticRoutes.get(`${method} ${normalizePath(path)}`);
   if (staticMatch) {
     return staticMatch;
   }

package/src/steps/async-support.steps.ts

@@ -365,9 +365,8 @@ describeFeature(feature, ({ Scenario }) => {
       responses = await Promise.all(promises);
     });
 
-    Then("all responses should have different processedAt timestamps", () => {
+    Then("all responses should have valid processedAt timestamps", () => {
       const timestamps = responses.map(r => r.body.processedAt);
-      // In fast test environments, timestamps might be the same, so just check they exist
       expect(timestamps).toHaveLength(3);
       timestamps.forEach((timestamp: number) => expect(timestamp).toBeGreaterThan(0));
     });
@@ -378,8 +377,7 @@ describeFeature(feature, ({ Scenario }) => {
       expect(responses[2].body.id).toBe("3");
     });
 
-    And("the responses should complete in expected order", () => {
-      // All responses should be successful regardless of timing
+    And("all responses should complete with status 200", () => {
       for (const response of responses) {
         expect(response.status).toBe(200);
         expect(response.body).toHaveProperty("id");

package/src/steps/performance-reliability.steps.ts

@@ -180,8 +180,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    And("the mock should handle the load gracefully", () => {
-      // If we got here without throwing, the mock handled the load
+    And("each response should confirm large payload processing", () => {
       expect(responses.every(r => r.body.size === 'large')).toBe(true);
     });
 
@@ -202,8 +201,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    And("the memory usage should remain stable", () => {
-      // Memory stability is tested by not crashing during multiple large requests
+    And("all accumulation requests should complete successfully", () => {
       expect(responses).toHaveLength(5);
     });
   });
@@ -262,13 +260,12 @@ describeFeature(feature, ({ Scenario }) => {
       expect(successCount + errorCount).toBe(responses.length);
     });
 
-    And("the success rate should be approximately {int}%", (_, expectedRate: number) => {
+    And("the success rate should be between {int}% and {int}%", (_, low: number, high: number) => {
       const successCount = responses.filter(r => r.status === 200).length;
       const actualRate = (successCount / responses.length) * 100;
 
-      // Allow for some variance due to randomness
-      expect(actualRate).toBeGreaterThan(expectedRate - 10);
-      expect(actualRate).toBeLessThan(expectedRate + 10);
+      expect(actualRate).toBeGreaterThanOrEqual(low);
+      expect(actualRate).toBeLessThanOrEqual(high);
     });
 
     And("error responses should have appropriate status codes", () => {
@@ -298,7 +295,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    Then("each error should have a specific, helpful error message", () => {
+    Then("each error response should have a non-empty error message", () => {
       for (const response of responses) {
         expect(response.status).toBeGreaterThanOrEqual(400);
         expect(response.body.error).toBeDefined();
@@ -307,7 +304,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    And("the error codes should correctly identify the validation issue", () => {
+    And("each error response should have the correct status code", () => {
       expect(responses[0].status).toBe(400); // No content-type
       expect(responses[1].status).toBe(400); // No body
       expect(responses[2].status).toBe(400); // Invalid body type

package/src/steps/plugin-integration.steps.ts

@@ -259,13 +259,14 @@ describeFeature(feature, ({ Scenario }) => {
       requestResponses = [await mock.handle(method as any, path)];
     });
 
-    Then("the response should have a {string} array", (_, property: string) => {
+    Then("the response should have a {string} array with {int} items", (_, property: string, count: number) => {
       expect(requestResponses[0].body).toHaveProperty(property);
       expect(Array.isArray(requestResponses[0].body[property])).toBe(true);
+      expect(requestResponses[0].body[property]).toHaveLength(count);
     });
 
-    And("the response should have a {string} field", (_, property: string) => {
-      expect(requestResponses[0].body).toHaveProperty(property);
+    And("the response should have {string} equal to {int}", (_, property: string, value: number) => {
+      expect(requestResponses[0].body[property]).toBe(value);
     });
 
     And(

package/src/steps/response-delay.steps.ts

@@ -58,8 +58,8 @@ describeFeature(feature, ({ Scenario }) => {
       elapsed = performance.now() - start;
     });
 
-    Then("the response took at least 10ms", () => {
-      expect(elapsed).toBeGreaterThanOrEqual(8); // small tolerance
+    Then("the response took at least 8ms", () => {
+      expect(elapsed).toBeGreaterThanOrEqual(8);
     });
   });
 

package/src/steps/state-concurrency.steps.ts

@@ -533,18 +533,18 @@ describeFeature(feature, ({ Scenario }) => {
       responses = await Promise.all(promises);
     });
 
-    Then("the cache should maintain its size limit", () => {
+    Then("no response should report a cache size above 5", () => {
       responses.forEach(response => {
         expect((response.body as CacheResponseBody).cacheSize).toBeLessThanOrEqual(5);
       });
     });
 
-    And("old items should be evicted properly", () => {
+    And("the final cache size should be 5", () => {
       const finalCacheSize = Math.max(...responses.map(r => (r.body as CacheResponseBody).cacheSize));
       expect(finalCacheSize).toBe(5);
     });
 
-    And("cache size should remain consistent", () => {
+    And("each response should confirm the item was cached", () => {
       responses.forEach(response => {
         const body = response.body as CacheResponseBody;
         expect(body.cached).toBe(true);
@@ -617,7 +617,7 @@ describeFeature(feature, ({ Scenario }) => {
       expect(activityUpdates).toHaveLength(3);
     });
 
-    And("no cross-contamination should occur between user data", () => {
+    And("user 1 should have 4 updates and user 2 should have 2", () => {
       const user1Updates = responses.filter(r => (r.body as ProfileResponseBody).userId === "1");
       const user2Updates = responses.filter(r => (r.body as ProfileResponseBody).userId === "2");
 
@@ -625,13 +625,7 @@ describeFeature(feature, ({ Scenario }) => {
       expect(user2Updates).toHaveLength(2); // profile, activity
     });
 
-    And("nested state structure should remain intact", () => {
-      responses.forEach(response => {
-        const body = response.body as ProfileResponseBody;
-        expect(body.userId).toBeDefined();
-        expect(["1", "2"]).toContain(body.userId);
-      });
-
+    And("user 1 activity count should be 2", () => {
       const activityUpdates = responses.filter(r => (r.body as ProfileResponseBody).activityCount);
       const user1Activities = activityUpdates.filter(r => (r.body as ProfileResponseBody).userId === "1");
       expect(user1Activities.length).toBe(2);
@@ -733,7 +727,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    And("transaction history should be consistent", () => {
+    And("the transaction count should match the number of successful transactions", () => {
       const successfulTransactions = responses.filter(r => (r.body as TransactionResponseBody).success === true);
       if (successfulTransactions.length > 0) {
         const transactionCounts = successfulTransactions.map(r => (r.body as TransactionResponseBody).transactionCount);