@schmock/validation 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import type { JSONSchema7 } from "json-schema";
+interface ValidationRules {
+    request?: {
+        body?: JSONSchema7;
+        query?: JSONSchema7;
+        headers?: JSONSchema7;
+    };
+    response?: {
+        body?: JSONSchema7;
+    };
+}
+interface ValidationPluginOptions extends ValidationRules {
+    /** Custom status code for request validation failures (default: 400) */
+    requestErrorStatus?: number;
+    /** Custom status code for response validation failures (default: 500) */
+    responseErrorStatus?: number;
+}
+export declare function validationPlugin(options: ValidationPluginOptions): Schmock.Plugin;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,UAAU,eAAe;IACvB,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,WAAW,CAAC;QACnB,KAAK,CAAC,EAAE,WAAW,CAAC;QACpB,OAAO,CAAC,EAAE,WAAW,CAAC;KACvB,CAAC;IACF,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,WAAW,CAAC;KACpB,CAAC;CACH;AAED,UAAU,uBAAwB,SAAQ,eAAe;IACvD,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,yEAAyE;IACzE,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,MAAM,CAmHhB"}

package/dist/index.js

@@ -0,0 +1,100 @@
+/// <reference path="../../../types/schmock.d.ts" />
+import Ajv from "ajv";
+export function validationPlugin(options) {
+    const requestErrorStatus = options.requestErrorStatus ?? 400;
+    const responseErrorStatus = options.responseErrorStatus ?? 500;
+    // Pre-compile all validators at plugin creation time
+    const ajv = new Ajv({ allErrors: true });
+    const validators = {};
+    if (options.request?.body) {
+        validators.requestBody = ajv.compile(options.request.body);
+    }
+    if (options.request?.query) {
+        validators.requestQuery = ajv.compile(options.request.query);
+    }
+    if (options.request?.headers) {
+        validators.requestHeaders = ajv.compile(options.request.headers);
+    }
+    if (options.response?.body) {
+        validators.responseBody = ajv.compile(options.response.body);
+    }
+    return {
+        name: "validation",
+        version: "1.0.0",
+        process(context, response) {
+            // Validate request body (skip when no body provided, e.g. GET requests)
+            if (validators.requestBody && context.body !== undefined) {
+                if (!validators.requestBody(context.body)) {
+                    return {
+                        context,
+                        response: {
+                            status: requestErrorStatus,
+                            body: {
+                                error: "Request validation failed",
+                                code: "REQUEST_VALIDATION_ERROR",
+                                details: validators.requestBody.errors,
+                            },
+                        },
+                    };
+                }
+            }
+            // Validate request query parameters
+            if (validators.requestQuery && context.query) {
+                if (!validators.requestQuery(context.query)) {
+                    return {
+                        context,
+                        response: {
+                            status: requestErrorStatus,
+                            body: {
+                                error: "Query parameter validation failed",
+                                code: "QUERY_VALIDATION_ERROR",
+                                details: validators.requestQuery.errors,
+                            },
+                        },
+                    };
+                }
+            }
+            // Validate request headers
+            if (validators.requestHeaders && context.headers) {
+                // Lowercase all header names for comparison
+                const normalizedHeaders = {};
+                for (const [key, value] of Object.entries(context.headers)) {
+                    normalizedHeaders[key.toLowerCase()] = value;
+                }
+                if (!validators.requestHeaders(normalizedHeaders)) {
+                    return {
+                        context,
+                        response: {
+                            status: requestErrorStatus,
+                            body: {
+                                error: "Header validation failed",
+                                code: "HEADER_VALIDATION_ERROR",
+                                details: validators.requestHeaders.errors,
+                            },
+                        },
+                    };
+                }
+            }
+            // Validate response body (if response exists)
+            if (validators.responseBody && response !== undefined) {
+                // Unwrap tuple responses: [status, body] or [status, body, headers]
+                const isTuple = Array.isArray(response) && typeof response[0] === "number";
+                const responseBody = isTuple ? response[1] : response;
+                if (!validators.responseBody(responseBody)) {
+                    return {
+                        context,
+                        response: {
+                            status: responseErrorStatus,
+                            body: {
+                                error: "Response validation failed",
+                                code: "RESPONSE_VALIDATION_ERROR",
+                                details: validators.responseBody.errors,
+                            },
+                        },
+                    };
+                }
+            }
+            return { context, response };
+        },
+    };
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@schmock/validation",
+  "description": "Request/response validation plugin for Schmock",
+  "version": "1.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "bun build:lib && bun build:types",
+    "build:lib": "bun build --minify --outdir=dist src/index.ts",
+    "build:types": "tsc -p tsconfig.json",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:bdd": "vitest run --config vitest.config.bdd.ts",
+    "lint": "biome check src/*.ts",
+    "lint:fix": "biome check --write --unsafe src/*.ts"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "ajv": "^8.17.1"
+  },
+  "peerDependencies": {
+    "@schmock/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@amiceli/vitest-cucumber": "^6.2.0",
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^25.1.0",
+    "vitest": "^4.0.15"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from "vitest";
+import { validationPlugin } from "./index";
+
+describe("validationPlugin", () => {
+  it("creates a plugin with correct name", () => {
+    const plugin = validationPlugin({
+      request: {
+        body: { type: "object" },
+      },
+    });
+    expect(plugin.name).toBe("validation");
+    expect(plugin.version).toBe("1.0.0");
+  });
+
+  it("passes through non-matching requests", async () => {
+    const plugin = validationPlugin({
+      request: {
+        body: {
+          type: "object",
+          required: ["name"],
+          properties: { name: { type: "string" } },
+        },
+      },
+    });
+
+    // No body in context — validation skipped
+    const result = await plugin.process(
+      {
+        path: "/test",
+        route: {},
+        method: "GET",
+        params: {},
+        query: {},
+        headers: {},
+        state: new Map(),
+      },
+      "original response",
+    );
+
+    expect(result.response).toBe("original response");
+  });
+
+  it("rejects invalid request body", async () => {
+    const plugin = validationPlugin({
+      request: {
+        body: {
+          type: "object",
+          required: ["name"],
+          properties: { name: { type: "string" } },
+        },
+      },
+    });
+
+    const result = await plugin.process(
+      {
+        path: "/test",
+        route: {},
+        method: "POST",
+        params: {},
+        query: {},
+        headers: {},
+        body: { age: 25 },
+        state: new Map(),
+      },
+      undefined,
+    );
+
+    expect(result.response).toEqual(
+      expect.objectContaining({
+        status: 400,
+        body: expect.objectContaining({
+          code: "REQUEST_VALIDATION_ERROR",
+        }),
+      }),
+    );
+  });
+
+  it("validates response body", async () => {
+    const plugin = validationPlugin({
+      response: {
+        body: {
+          type: "object",
+          required: ["id"],
+          properties: { id: { type: "number" } },
+        },
+      },
+    });
+
+    const result = await plugin.process(
+      {
+        path: "/test",
+        route: {},
+        method: "GET",
+        params: {},
+        query: {},
+        headers: {},
+        state: new Map(),
+      },
+      { id: "not-a-number" },
+    );
+
+    expect(result.response).toEqual(
+      expect.objectContaining({
+        status: 500,
+        body: expect.objectContaining({
+          code: "RESPONSE_VALIDATION_ERROR",
+        }),
+      }),
+    );
+  });
+
+  it("uses custom error status codes", async () => {
+    const plugin = validationPlugin({
+      request: {
+        body: {
+          type: "object",
+          required: ["name"],
+          properties: { name: { type: "string" } },
+        },
+      },
+      requestErrorStatus: 422,
+    });
+
+    const result = await plugin.process(
+      {
+        path: "/test",
+        route: {},
+        method: "POST",
+        params: {},
+        query: {},
+        headers: {},
+        body: {},
+        state: new Map(),
+      },
+      undefined,
+    );
+
+    expect(result.response).toEqual(expect.objectContaining({ status: 422 }));
+  });
+});

package/src/index.ts

@@ -0,0 +1,141 @@
+/// <reference path="../../../types/schmock.d.ts" />
+
+import Ajv, { type ValidateFunction } from "ajv";
+import type { JSONSchema7 } from "json-schema";
+
+interface ValidationRules {
+  request?: {
+    body?: JSONSchema7;
+    query?: JSONSchema7;
+    headers?: JSONSchema7;
+  };
+  response?: {
+    body?: JSONSchema7;
+  };
+}
+
+interface ValidationPluginOptions extends ValidationRules {
+  /** Custom status code for request validation failures (default: 400) */
+  requestErrorStatus?: number;
+  /** Custom status code for response validation failures (default: 500) */
+  responseErrorStatus?: number;
+}
+
+export function validationPlugin(
+  options: ValidationPluginOptions,
+): Schmock.Plugin {
+  const requestErrorStatus = options.requestErrorStatus ?? 400;
+  const responseErrorStatus = options.responseErrorStatus ?? 500;
+
+  // Pre-compile all validators at plugin creation time
+  const ajv = new Ajv({ allErrors: true });
+  const validators: {
+    requestBody?: ValidateFunction;
+    requestQuery?: ValidateFunction;
+    requestHeaders?: ValidateFunction;
+    responseBody?: ValidateFunction;
+  } = {};
+
+  if (options.request?.body) {
+    validators.requestBody = ajv.compile(options.request.body);
+  }
+  if (options.request?.query) {
+    validators.requestQuery = ajv.compile(options.request.query);
+  }
+  if (options.request?.headers) {
+    validators.requestHeaders = ajv.compile(options.request.headers);
+  }
+  if (options.response?.body) {
+    validators.responseBody = ajv.compile(options.response.body);
+  }
+
+  return {
+    name: "validation",
+    version: "1.0.0",
+
+    process(
+      context: Schmock.PluginContext,
+      response?: unknown,
+    ): Schmock.PluginResult {
+      // Validate request body (skip when no body provided, e.g. GET requests)
+      if (validators.requestBody && context.body !== undefined) {
+        if (!validators.requestBody(context.body)) {
+          return {
+            context,
+            response: {
+              status: requestErrorStatus,
+              body: {
+                error: "Request validation failed",
+                code: "REQUEST_VALIDATION_ERROR",
+                details: validators.requestBody.errors,
+              },
+            },
+          };
+        }
+      }
+
+      // Validate request query parameters
+      if (validators.requestQuery && context.query) {
+        if (!validators.requestQuery(context.query)) {
+          return {
+            context,
+            response: {
+              status: requestErrorStatus,
+              body: {
+                error: "Query parameter validation failed",
+                code: "QUERY_VALIDATION_ERROR",
+                details: validators.requestQuery.errors,
+              },
+            },
+          };
+        }
+      }
+
+      // Validate request headers
+      if (validators.requestHeaders && context.headers) {
+        // Lowercase all header names for comparison
+        const normalizedHeaders: Record<string, string> = {};
+        for (const [key, value] of Object.entries(context.headers)) {
+          normalizedHeaders[key.toLowerCase()] = value;
+        }
+        if (!validators.requestHeaders(normalizedHeaders)) {
+          return {
+            context,
+            response: {
+              status: requestErrorStatus,
+              body: {
+                error: "Header validation failed",
+                code: "HEADER_VALIDATION_ERROR",
+                details: validators.requestHeaders.errors,
+              },
+            },
+          };
+        }
+      }
+
+      // Validate response body (if response exists)
+      if (validators.responseBody && response !== undefined) {
+        // Unwrap tuple responses: [status, body] or [status, body, headers]
+        const isTuple =
+          Array.isArray(response) && typeof response[0] === "number";
+        const responseBody = isTuple ? response[1] : response;
+
+        if (!validators.responseBody(responseBody)) {
+          return {
+            context,
+            response: {
+              status: responseErrorStatus,
+              body: {
+                error: "Response validation failed",
+                code: "RESPONSE_VALIDATION_ERROR",
+                details: validators.responseBody.errors,
+              },
+            },
+          };
+        }
+      }
+
+      return { context, response };
+    },
+  };
+}

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

@@ -0,0 +1,268 @@
+import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
+import { schmock } from "@schmock/core";
+import { expect } from "vitest";
+import { validationPlugin } from "../index";
+
+const feature = await loadFeature("../../features/validation-plugin.feature");
+
+describeFeature(feature, ({ Scenario }) => {
+  let mock: any;
+  let response: any;
+
+  Scenario("Valid request body passes validation", ({ Given, When, Then, And }) => {
+    Given("I create a validated mock that requires name and email", () => {
+      mock = schmock();
+      mock("POST /users", ({ body }: any) => [201, body])
+        .pipe(validationPlugin({
+          request: {
+            body: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                email: { type: "string" },
+              },
+              required: ["name", "email"],
+            },
+          },
+        }));
+    });
+
+    When("I send a valid POST with name {string} and email {string}", async (_, name: string, email: string) => {
+      response = await mock.handle("POST", "/users", {
+        body: { name, email },
+      });
+    });
+
+    Then("the status should be {int}", (_, status: number) => {
+      expect(response.status).toBe(status);
+    });
+
+    And("the response body should have property {string} with value {string}", (_, prop: string, value: string) => {
+      expect(response.body[prop]).toBe(value);
+    });
+  });
+
+  Scenario("Invalid request body returns 400", ({ Given, When, Then, And }) => {
+    Given("I create a validated mock that requires name and email", () => {
+      mock = schmock();
+      mock("POST /users", ({ body }: any) => [201, body])
+        .pipe(validationPlugin({
+          request: {
+            body: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                email: { type: "string" },
+              },
+              required: ["name", "email"],
+            },
+          },
+        }));
+    });
+
+    When("I send an invalid POST missing required fields", async () => {
+      response = await mock.handle("POST", "/users", {
+        body: { name: "John" },
+      });
+    });
+
+    Then("the status should be {int}", (_, status: number) => {
+      expect(response.status).toBe(status);
+    });
+
+    And("the response body should have error code {string}", (_, code: string) => {
+      expect(response.body.code).toBe(code);
+    });
+  });
+
+  Scenario("Invalid response body returns 500", ({ Given, When, Then, And }) => {
+    Given("I create a mock with response validation that expects a number id", () => {
+      mock = schmock();
+      mock("GET /item", { id: "not-a-number", name: "Test" })
+        .pipe(validationPlugin({
+          response: {
+            body: {
+              type: "object",
+              properties: {
+                id: { type: "number" },
+                name: { type: "string" },
+              },
+              required: ["id"],
+            },
+          },
+        }));
+    });
+
+    When("I request the endpoint", async () => {
+      response = await mock.handle("GET", "/item");
+    });
+
+    Then("the status should be {int}", (_, status: number) => {
+      expect(response.status).toBe(status);
+    });
+
+    And("the response body should have error code {string}", (_, code: string) => {
+      expect(response.body.code).toBe(code);
+    });
+  });
+
+  Scenario("Valid response passes validation", ({ Given, When, Then, And }) => {
+    Given("I create a mock with valid response and response validation", () => {
+      mock = schmock();
+      mock("GET /item", { id: 42, name: "Test" })
+        .pipe(validationPlugin({
+          response: {
+            body: {
+              type: "object",
+              properties: {
+                id: { type: "number" },
+                name: { type: "string" },
+              },
+              required: ["id"],
+            },
+          },
+        }));
+    });
+
+    When("I request the endpoint", async () => {
+      response = await mock.handle("GET", "/item");
+    });
+
+    Then("the status should be {int}", (_, status: number) => {
+      expect(response.status).toBe(status);
+    });
+
+    And("the response body should have property {string} with numeric value", (_, prop: string) => {
+      expect(typeof response.body[prop]).toBe("number");
+    });
+  });
+
+  Scenario("Header validation rejects missing required headers", ({ Given, When, Then, And }) => {
+    Given("I create a mock requiring an authorization header", () => {
+      mock = schmock();
+      mock("GET /secure", { data: "secret" })
+        .pipe(validationPlugin({
+          request: {
+            headers: {
+              type: "object",
+              properties: {
+                authorization: { type: "string" },
+              },
+              required: ["authorization"],
+            },
+          },
+        }));
+    });
+
+    When("I request without authorization header", async () => {
+      response = await mock.handle("GET", "/secure");
+    });
+
+    Then("the status should be {int}", (_, status: number) => {
+      expect(response.status).toBe(status);
+    });
+
+    And("the response body should have error code {string}", (_, code: string) => {
+      expect(response.body.code).toBe(code);
+    });
+  });
+
+  Scenario("Header validation passes with required headers", ({ Given, When, Then }) => {
+    Given("I create a mock requiring an authorization header", () => {
+      mock = schmock();
+      mock("GET /secure", { data: "secret" })
+        .pipe(validationPlugin({
+          request: {
+            headers: {
+              type: "object",
+              properties: {
+                authorization: { type: "string" },
+              },
+              required: ["authorization"],
+            },
+          },
+        }));
+    });
+
+    When("I request with authorization header {string}", async (_, token: string) => {
+      response = await mock.handle("GET", "/secure", {
+        headers: { authorization: token },
+      });
+    });
+
+    Then("the status should be {int}", (_, status: number) => {
+      expect(response.status).toBe(status);
+    });
+  });
+
+  Scenario("Query parameter validation", ({ Given, When, Then, And }) => {
+    let invalidQueryResponse: any;
+
+    Given("I create a mock requiring page query parameter", () => {
+      mock = schmock();
+      mock("GET /items", [{ id: 1 }])
+        .pipe(validationPlugin({
+          request: {
+            query: {
+              type: "object",
+              properties: {
+                page: { type: "string" },
+              },
+              required: ["page"],
+            },
+          },
+        }));
+    });
+
+    When("I request with query page {string}", async (_, page: string) => {
+      response = await mock.handle("GET", "/items", {
+        query: { page },
+      });
+    });
+
+    Then("the status should be {int}", (_, status: number) => {
+      expect(response.status).toBe(status);
+    });
+
+    When("I request without required query parameter", async () => {
+      invalidQueryResponse = await mock.handle("GET", "/items");
+    });
+
+    Then("the invalid query status should be {int}", (_, status: number) => {
+      expect(invalidQueryResponse.status).toBe(status);
+    });
+
+    And("the invalid query response should have error code {string}", (_, code: string) => {
+      expect(invalidQueryResponse.body.code).toBe(code);
+    });
+  });
+
+  Scenario("Custom error status codes", ({ Given, When, Then }) => {
+    Given("I create a validated mock with custom error status {int}", (_, status: number) => {
+      mock = schmock();
+      mock("POST /users", ({ body }: any) => [201, body])
+        .pipe(validationPlugin({
+          request: {
+            body: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+              },
+              required: ["name"],
+            },
+          },
+          requestErrorStatus: status,
+        }));
+    });
+
+    When("I send an invalid request body", async () => {
+      response = await mock.handle("POST", "/users", {
+        body: {},
+      });
+    });
+
+    Then("the status should be {int}", (_, status: number) => {
+      expect(response.status).toBe(status);
+    });
+  });
+});