@schmock/core 2.3.0 → 2.3.1

package/src/response-parser.ts

@@ -1,114 +0,0 @@
-import { isBinaryBody } from "./binary.js";
-import { isStatusTuple } from "./constants.js";
-
-const BINARY_CONTENT_TYPE = "application/octet-stream";
-
-function hasContentType(headers: Record<string, string>): boolean {
-  return Object.keys(headers).some(
-    (header) => header.toLowerCase() === "content-type",
-  );
-}
-
-function isResponseObject(value: unknown): value is {
-  status: number;
-  body: unknown;
-  headers?: Record<string, string>;
-} {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "status" in value &&
-    typeof value.status === "number" &&
-    "body" in value &&
-    (!("headers" in value) ||
-      value.headers === undefined ||
-      isStringRecord(value.headers))
-  );
-}
-
-function isStringRecord(value: unknown): value is Record<string, string> {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    Object.values(value).every((entry) => typeof entry === "string")
-  );
-}
-
-/**
- * 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)) {
-    status = result.status;
-    body = result.body;
-    headers = result.headers ?? {};
-    tupleFormat = true;
-  } else if (isStatusTuple(result)) {
-    // Handle tuple response format [status, body, headers?]
-    [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
-  }
-
-  const binaryBody = isBinaryBody(body);
-
-  // Binary response values need a transport-safe MIME type. Tuple headers still
-  // take precedence, while a non-JSON route override (for example image/png)
-  // remains authoritative for non-tuple responses.
-  if (!hasContentType(headers) && binaryBody) {
-    headers["content-type"] =
-      !tupleFormat &&
-      routeConfig.contentType &&
-      routeConfig.contentType !== "application/json"
-        ? routeConfig.contentType
-        : BINARY_CONTENT_TYPE;
-  }
-
-  // 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)
-  let appliedRouteContentType = false;
-  if (!hasContentType(headers) && routeConfig.contentType && !tupleFormat) {
-    headers["content-type"] = routeConfig.contentType;
-    appliedRouteContentType = true;
-  }
-
-  // Handle special conversion cases when contentType is explicitly set. A
-  // binary body keeps its bytes even when a custom MIME type is configured.
-  if (
-    appliedRouteContentType &&
-    routeConfig.contentType === "text/plain" &&
-    body !== undefined &&
-    !binaryBody
-  ) {
-    if (typeof body === "object") {
-      body = JSON.stringify(body);
-    } else if (typeof body !== "string") {
-      body = String(body);
-    }
-  }
-
-  return {
-    status,
-    body,
-    headers,
-  };
-}

package/src/response-parsing.test.ts

@@ -1,333 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { schmock } from "./index";
-
-describe("response parsing", () => {
-  describe("tuple response formats", () => {
-    it("treats single-element array [status] as data, not tuple", async () => {
-      const mock = schmock();
-      mock("GET /status-only", () => [204] as [number]);
-
-      const response = await mock.handle("GET", "/status-only");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual([204]);
-    });
-
-    it("handles [status, body] tuple", async () => {
-      const mock = schmock();
-      mock("POST /create", () => [201, { id: 123, created: true }]);
-
-      const response = await mock.handle("POST", "/create");
-
-      expect(response.status).toBe(201);
-      expect(response.body).toEqual({ id: 123, created: true });
-      expect(response.headers).toEqual({});
-    });
-
-    it("handles [status, body, headers] tuple", async () => {
-      const mock = schmock();
-      mock(
-        "POST /upload",
-        () =>
-          [
-            201,
-            { fileId: "abc123" },
-            {
-              Location: "/files/abc123",
-              "Content-Type": "application/json",
-            },
-          ] as [number, any, Record<string, string>],
-      );
-
-      const response = await mock.handle("POST", "/upload");
-
-      expect(response.status).toBe(201);
-      expect(response.body).toEqual({ fileId: "abc123" });
-      expect(response.headers).toEqual({
-        Location: "/files/abc123",
-        "Content-Type": "application/json",
-      });
-    });
-
-    it("handles empty headers object in tuple", async () => {
-      const mock = schmock();
-      mock("GET /test", () => [200, "OK", {}]);
-
-      const response = await mock.handle("GET", "/test");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toBe("OK");
-      expect(response.headers).toEqual({});
-    });
-
-    it("treats arrays with more than 3 elements as data, not tuple", async () => {
-      const mock = schmock();
-      mock(
-        "GET /extra",
-        () => [200, "data", {}, "ignored", "also-ignored"] as any,
-      );
-
-      const response = await mock.handle("GET", "/extra");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual([
-        200,
-        "data",
-        {},
-        "ignored",
-        "also-ignored",
-      ]);
-    });
-
-    it("treats non-numeric first element as body, not status", async () => {
-      const mock = schmock();
-      mock("GET /array-body", () => ["item1", "item2", "item3"]);
-
-      const response = await mock.handle("GET", "/array-body");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual(["item1", "item2", "item3"]);
-      expect(response.headers).toEqual({ "content-type": "application/json" });
-    });
-  });
-
-  describe("various response types", () => {
-    it("handles string responses", async () => {
-      const mock = schmock();
-      mock("GET /text", () => "Simple text response");
-
-      const response = await mock.handle("GET", "/text");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toBe("Simple text response");
-      expect(response.headers).toEqual({ "content-type": "application/json" });
-    });
-
-    it("handles number responses", async () => {
-      const mock = schmock();
-      mock("GET /number", () => 42);
-
-      const response = await mock.handle("GET", "/number");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toBe(42);
-      expect(response.headers).toEqual({ "content-type": "application/json" });
-    });
-
-    it("handles boolean responses", async () => {
-      const mock = schmock();
-      mock("GET /bool", () => true);
-
-      const response = await mock.handle("GET", "/bool");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toBe(true);
-      expect(response.headers).toEqual({ "content-type": "application/json" });
-    });
-
-    it("handles null responses", async () => {
-      const mock = schmock();
-      mock("GET /null", () => null);
-
-      const response = await mock.handle("GET", "/null");
-
-      expect(response.status).toBe(204);
-      expect(response.body).toBeUndefined();
-      expect(response.headers).toEqual({ "content-type": "application/json" });
-    });
-
-    it("handles undefined responses", async () => {
-      const mock = schmock();
-      mock("GET /undefined", () => undefined);
-
-      const response = await mock.handle("GET", "/undefined");
-
-      expect(response.status).toBe(204);
-      expect(response.body).toBeUndefined();
-      expect(response.headers).toEqual({ "content-type": "application/json" });
-    });
-
-    it("handles complex object responses", async () => {
-      const complexObject = {
-        data: {
-          users: [
-            { id: 1, name: "Alice", tags: ["admin", "active"] },
-            { id: 2, name: "Bob", meta: { lastLogin: "2023-01-01" } },
-          ],
-          pagination: {
-            page: 1,
-            limit: 10,
-            total: 2,
-          },
-        },
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      const mock = schmock();
-      mock("GET /complex", () => complexObject);
-
-      const response = await mock.handle("GET", "/complex");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual(complexObject);
-      expect(response.headers).toEqual({ "content-type": "application/json" });
-    });
-
-    it("handles empty array responses", async () => {
-      const mock = schmock();
-      mock("GET /empty-array", () => []);
-
-      const response = await mock.handle("GET", "/empty-array");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual([]);
-      expect(response.headers).toEqual({ "content-type": "application/json" });
-    });
-
-    it("handles empty object responses", async () => {
-      const mock = schmock();
-      mock("GET /empty-object", () => ({}));
-
-      const response = await mock.handle("GET", "/empty-object");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual({});
-      expect(response.headers).toEqual({ "content-type": "application/json" });
-    });
-  });
-
-  describe("async response functions", () => {
-    it("handles async response functions", async () => {
-      const mock = schmock();
-      mock("GET /async", async () => {
-        await new Promise((resolve) => setTimeout(resolve, 1));
-        return { async: true };
-      });
-
-      const response = await mock.handle("GET", "/async");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual({ async: true });
-    });
-
-    it("handles async tuple responses", async () => {
-      const mock = schmock();
-      mock("POST /async-create", async () => {
-        await new Promise((resolve) => setTimeout(resolve, 1));
-        return [201, { created: true }, { "X-Async": "true" }];
-      });
-
-      const response = await mock.handle("POST", "/async-create");
-
-      expect(response.status).toBe(201);
-      expect(response.body).toEqual({ created: true });
-      expect(response.headers).toEqual({ "X-Async": "true" });
-    });
-  });
-
-  describe("status code boundaries", () => {
-    it("status code 100 (lower boundary) is accepted as tuple", async () => {
-      const mock = schmock();
-      mock("GET /continue", () => [100, "Continue"]);
-
-      const response = await mock.handle("GET", "/continue");
-      expect(response.status).toBe(100);
-      expect(response.body).toBe("Continue");
-    });
-
-    it("status code 599 (upper boundary) is accepted as tuple", async () => {
-      const mock = schmock();
-      mock("GET /custom", () => [599, { message: "custom status" }]);
-
-      const response = await mock.handle("GET", "/custom");
-      expect(response.status).toBe(599);
-      expect(response.body).toEqual({ message: "custom status" });
-    });
-
-    it("float status like 200.5 is accepted as tuple (number check)", async () => {
-      const mock = schmock();
-      mock("GET /float", () => [200.5, { ok: true }]);
-
-      const response = await mock.handle("GET", "/float");
-      // isStatusTuple checks typeof === 'number' and 100 <= n <= 599
-      // 200.5 passes both checks, so it's treated as a tuple
-      expect(response.status).toBe(200.5);
-      expect(response.body).toEqual({ ok: true });
-    });
-
-    it("array [201, null, undefined] — tuple with undefined headers defaults to empty", async () => {
-      const mock = schmock();
-      mock("GET /null-headers", () => [201, null, undefined] as any);
-
-      const response = await mock.handle("GET", "/null-headers");
-      // isStatusTuple: length 3, first element 201 (number, 100-599) -> true
-      // destructure: [status=201, body=null, headers=undefined]
-      // headers defaults to {} via `headers = {}`
-      expect(response.status).toBe(201);
-      expect(response.body).toBeUndefined(); // null body becomes undefined
-      expect(response.headers).toEqual({});
-    });
-
-    it("non-tuple array [1, 2, 3, 4] with length > 3 treated as body", async () => {
-      const mock = schmock();
-      mock("GET /long-array", () => [1, 2, 3, 4] as any);
-
-      const response = await mock.handle("GET", "/long-array");
-      // isStatusTuple requires length 2 or 3, so length 4 => not a tuple => body
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual([1, 2, 3, 4]);
-    });
-
-    it("status 99 (below 100) is NOT treated as a tuple", async () => {
-      const mock = schmock();
-      mock("GET /below-range", () => [99, { data: true }]);
-
-      const response = await mock.handle("GET", "/below-range");
-      // isStatusTuple requires value[0] >= 100, so 99 fails => treated as body
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual([99, { data: true }]);
-    });
-
-    it("status 600 (above 599) is NOT treated as a tuple", async () => {
-      const mock = schmock();
-      mock("GET /above-range", () => [600, { data: true }]);
-
-      const response = await mock.handle("GET", "/above-range");
-      // isStatusTuple requires value[0] <= 599, so 600 fails => treated as body
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual([600, { data: true }]);
-    });
-  });
-
-  describe("edge cases", () => {
-    it("handles response with circular references gracefully", async () => {
-      const mock = schmock();
-      mock("GET /circular", () => {
-        const obj: any = { name: "test" };
-        obj.self = obj; // Create circular reference
-        return obj;
-      });
-
-      const response = await mock.handle("GET", "/circular");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toHaveProperty("name", "test");
-      expect(response.body).toHaveProperty("self");
-    });
-
-    it("preserves functions in response objects", async () => {
-      const mock = schmock();
-      mock("GET /with-functions", () => ({
-        data: "test",
-        fn: () => "function result",
-      }));
-
-      const response = await mock.handle("GET", "/with-functions");
-
-      expect(response.status).toBe(200);
-      expect(response.body.data).toBe("test");
-      expect(typeof response.body.fn).toBe("function");
-      expect(response.body.fn()).toBe("function result");
-    });
-  });
-});

package/src/route-matcher.ts

@@ -1,69 +0,0 @@
-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;
-}