@schmock/core 2.3.0 → 2.3.1

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "@schmock/core",
   "description": "Core functionality for Schmock",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/khalic-lab/schmock.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/khalic-lab/schmock/tree/main/packages/core#readme",
+  "bugs": {
+    "url": "https://github.com/khalic-lab/schmock/issues"
+  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "exports": {
     ".": {
@@ -18,8 +26,9 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "bun build:lib && bun build:types",
-    "build:lib": "bun build --minify --target node --outdir=dist src/index.ts",
+    "clean": "rm -rf dist && rm -f tsconfig.tsbuildinfo",
+    "build": "bun run clean && bun run build:lib && bun run build:types",
+    "build:lib": "tsc -p tsconfig.runtime.json",
     "build:types": "rm -f tsconfig.tsbuildinfo && tsc --build && node scripts/embed-ambient-types.js",
     "pretest": "rm -f src/*.js src/*.d.ts || true",
     "test": "vitest run",
@@ -37,7 +46,6 @@
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^7.0.0",
     "@types/node": "^26.1.0",
-    "@vitest/ui": "^4.1.9",
     "vitest": "^4.1.9"
   }
 }

package/src/audit-core-builder.test.ts

@@ -1,218 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { schmock } from "./index";
-
-// ── FIX 1.2: defineRoute must shallow-clone the config ────────────────────────
-
-describe("FIX 1.2 — defineRoute must not mutate the caller's config", () => {
-  it("does not add contentType to the caller's config object", () => {
-    const sharedConfig: Schmock.RouteConfig = {};
-    const mock = schmock();
-    mock("GET /a", { x: 1 }, sharedConfig);
-    // sharedConfig must remain empty — defineRoute must work on a clone
-    expect(Object.keys(sharedConfig)).toHaveLength(0);
-  });
-
-  it("second route registered with same config is not polluted by first route detection", () => {
-    const sharedConfig: Schmock.RouteConfig = {};
-    const mock = schmock();
-    mock("GET /first", { x: 1 }, sharedConfig);
-    mock("GET /second", "hello", sharedConfig);
-    // sharedConfig must still be clean — neither call should have written to it
-    expect(Object.keys(sharedConfig)).toHaveLength(0);
-  });
-
-  it("mutating caller's config after registration does not change the registered route response", async () => {
-    const config: Schmock.RouteConfig = {};
-    const mock = schmock();
-    mock("GET /item", { value: 99 }, config);
-
-    // After registration, mutate the caller's config
-    config.status = 503;
-    config.contentType = "text/html";
-
-    const response = await mock.handle("GET", "/item");
-    // The registered route must use its own cloned config — not 503
-    expect(response.status).toBe(200);
-    const ct =
-      response.headers?.["content-type"] ?? response.headers?.["Content-Type"];
-    expect(ct).toContain("application/json");
-  });
-
-  it("each route keeps its own detected contentType even when sharing the same config object", async () => {
-    const sharedConfig: Schmock.RouteConfig = {};
-    const mock = schmock();
-    // First route: object → application/json
-    mock("GET /obj", { value: 1 }, sharedConfig);
-    // Second route: primitive string → text/plain
-    mock("GET /str", "hello", sharedConfig);
-
-    const objResp = await mock.handle("GET", "/obj");
-    const strResp = await mock.handle("GET", "/str");
-
-    const ctObj =
-      objResp.headers?.["content-type"] ?? objResp.headers?.["Content-Type"];
-    const ctStr =
-      strResp.headers?.["content-type"] ?? strResp.headers?.["Content-Type"];
-
-    expect(ctObj).toContain("application/json");
-    expect(ctStr).toContain("text/plain");
-  });
-});
-
-// ── FIX 2.2: duplicate route detection must normalize trailing slash ──────────
-
-describe("FIX 2.2 — duplicate-route detection uses normalized paths", () => {
-  it("GET /users/ is treated as duplicate of GET /users", () => {
-    const mock = schmock();
-    mock("GET /users", [{ id: 1 }], {});
-    // Registering with trailing slash must not add a second route
-    mock("GET /users/", [{ id: 2 }], {});
-
-    const routes = mock.getRoutes();
-    const userRoutes = routes.filter(
-      (r) =>
-        r.method === "GET" && (r.path === "/users" || r.path === "/users/"),
-    );
-    expect(userRoutes).toHaveLength(1);
-  });
-
-  it("first registration wins — trailing-slash variant does not overwrite", async () => {
-    const mock = schmock();
-    mock("GET /items", [{ id: 1 }], {});
-    mock("GET /items/", [{ id: 999 }], {});
-
-    // Should still get the first registration's data
-    const resp = await mock.handle("GET", "/items");
-    expect(resp.status).toBe(200);
-    expect(Array.isArray(resp.body)).toBe(true);
-    expect((resp.body as { id: number }[])[0].id).toBe(1);
-  });
-
-  it("registering verbatim duplicate also produces only one route", () => {
-    const mock = schmock();
-    mock("GET /same", { ok: true }, {});
-    mock("GET /same", { ok: false }, {});
-
-    const routes = mock.getRoutes();
-    const sameRoutes = routes.filter(
-      (r) => r.method === "GET" && r.path === "/same",
-    );
-    expect(sameRoutes).toHaveLength(1);
-  });
-});
-
-// ── FIX 3.3: reset()/resetState() must reassign, not delete keys ─────────────
-
-describe("FIX 3.3 — reset()/resetState() must not mutate caller's state", () => {
-  it("reset() leaves the external state object untouched", () => {
-    const st = { a: 1 };
-    const mock = schmock({ state: st });
-    mock.reset();
-    expect(st).toEqual({ a: 1 });
-  });
-
-  it("resetState() leaves the external state object untouched", () => {
-    const st = { b: 2 };
-    const mock = schmock({ state: st });
-    mock.resetState();
-    expect(st).toEqual({ b: 2 });
-  });
-
-  it("mock.getState() is empty after reset()", () => {
-    const st = { x: 10 };
-    const mock = schmock({ state: st });
-    mock.reset();
-    expect(mock.getState()).toEqual({});
-  });
-
-  it("mock.getState() is empty after resetState()", () => {
-    const st = { y: 20 };
-    const mock = schmock({ state: st });
-    mock.resetState();
-    expect(mock.getState()).toEqual({});
-  });
-
-  it("generator sees empty state after resetState", async () => {
-    const st: Record<string, unknown> = { counter: 0 };
-    const mock = schmock({ state: st });
-    mock("GET /stateful", (ctx: Schmock.RequestContext) => {
-      return { stateKeys: Object.keys(ctx.state) };
-    });
-
-    mock.resetState();
-
-    const resp = await mock.handle("GET", "/stateful");
-    expect(resp.status).toBe(200);
-    // After resetState, the generator should see an empty state
-    expect((resp.body as { stateKeys: string[] }).stateKeys).toHaveLength(0);
-  });
-});
-
-// ── FIX 2.3: history()/lastRequest() must return deep clones ─────────────────
-
-describe("FIX 2.3 — history() and lastRequest() return deep clones", () => {
-  it("mutating a history() record's nested body does not corrupt internal history", async () => {
-    const mock = schmock();
-    mock("GET /nested", { deep: { value: "original" } }, {});
-
-    await mock.handle("GET", "/nested");
-
-    // First read: mutate the returned record's body
-    const records1 = mock.history();
-    const firstRecord = records1[0];
-    (firstRecord.response.body as { deep: { value: string } }).deep.value =
-      "MUTATED";
-
-    // Second read: internal history must be unchanged
-    const records2 = mock.history();
-    expect(
-      (records2[0].response.body as { deep: { value: string } }).deep.value,
-    ).toBe("original");
-  });
-
-  it("mutating filtered history() record does not corrupt internal history", async () => {
-    const mock = schmock();
-    mock("GET /data", { info: { count: 42 } }, {});
-    await mock.handle("GET", "/data");
-
-    const filtered = mock.history("GET", "/data");
-    (filtered[0].response.body as { info: { count: number } }).info.count = 0;
-
-    const again = mock.history("GET", "/data");
-    expect(
-      (again[0].response.body as { info: { count: number } }).info.count,
-    ).toBe(42);
-  });
-
-  it("mutating lastRequest() record does not corrupt internal history", async () => {
-    const mock = schmock();
-    mock("GET /last", { meta: { tag: "safe" } }, {});
-    await mock.handle("GET", "/last");
-
-    const last = mock.lastRequest();
-    if (!last) throw new Error("expected a record");
-    (last.response.body as { meta: { tag: string } }).meta.tag = "corrupted";
-
-    const again = mock.lastRequest();
-    if (!again) throw new Error("expected a record");
-    expect((again.response.body as { meta: { tag: string } }).meta.tag).toBe(
-      "safe",
-    );
-  });
-
-  it("mutating filtered lastRequest() record does not corrupt internal history", async () => {
-    const mock = schmock();
-    mock("POST /echo", { msg: { text: "hello" } }, {});
-    await mock.handle("POST", "/echo");
-
-    const last = mock.lastRequest("POST", "/echo");
-    if (!last) throw new Error("expected a record");
-    (last.response.body as { msg: { text: string } }).msg.text = "CHANGED";
-
-    const again = mock.lastRequest("POST", "/echo");
-    if (!again) throw new Error("expected a record");
-    expect((again.response.body as { msg: { text: string } }).msg.text).toBe(
-      "hello",
-    );
-  });
-});

package/src/audit-response-guard.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { schmock } from "./index";
-
-describe("isResponseObject guard — status type check", () => {
-  describe("non-numeric status must NOT be treated as response envelope", () => {
-    it("returns status 200 (default) when generator returns { status: 'ok', body: 'hello' }", async () => {
-      const mock = schmock();
-      mock("GET /bad-envelope", () => ({ status: "ok", body: "hello" }));
-
-      const response = await mock.handle("GET", "/bad-envelope");
-
-      // The string status must never leak into response.status
-      expect(response.status).toBe(200);
-    });
-
-    it("returns the whole object as body when generator returns { status: 'ok', body: 'hello' }", async () => {
-      const mock = schmock();
-      mock("GET /bad-envelope-body", () => ({ status: "ok", body: "hello" }));
-
-      const response = await mock.handle("GET", "/bad-envelope-body");
-
-      // The original object must be treated as plain body, not unwrapped
-      expect(response.body).toEqual({ status: "ok", body: "hello" });
-    });
-  });
-
-  describe("numeric status IS correctly treated as response envelope", () => {
-    it("returns status 201 and unwrapped body when generator returns { status: 201, body: { id: 1 } }", async () => {
-      const mock = schmock();
-      mock("POST /create", () => ({ status: 201, body: { id: 1 } }));
-
-      const response = await mock.handle("POST", "/create");
-
-      expect(response.status).toBe(201);
-      expect(response.body).toEqual({ id: 1 });
-    });
-  });
-});

package/src/binary.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isBinaryBody } from "./binary.js";
-import { schmock } from "./index.js";
-import { parseResponse } from "./response-parser.js";
-
-function binaryBytes(value: unknown): number[] {
-  if (value instanceof ArrayBuffer) {
-    return [...new Uint8Array(value)];
-  }
-  if (ArrayBuffer.isView(value)) {
-    return [
-      ...new Uint8Array(value.buffer, value.byteOffset, value.byteLength),
-    ];
-  }
-  throw new Error("Expected a binary response body");
-}
-
-describe("isBinaryBody", () => {
-  it("recognizes browser binary values without a Node Buffer global", () => {
-    expect(isBinaryBody(new Uint8Array([1, 2, 3]))).toBe(true);
-    expect(isBinaryBody(new ArrayBuffer(3))).toBe(true);
-    expect(isBinaryBody(new DataView(new SharedArrayBuffer(3)))).toBe(true);
-    expect(isBinaryBody({ 0: 1, length: 1 })).toBe(false);
-  });
-});
-
-describe("parseResponse binary handling", () => {
-  it("stringifies text objects when Buffer is not available", () => {
-    const originalBuffer = globalThis.Buffer;
-    Reflect.deleteProperty(globalThis, "Buffer");
-
-    try {
-      const response = parseResponse(
-        { message: "browser" },
-        { contentType: "text/plain" },
-      );
-
-      expect(response.body).toBe('{"message":"browser"}');
-    } finally {
-      globalThis.Buffer = originalBuffer;
-    }
-  });
-
-  it("detects binary returned by a dynamic generator", async () => {
-    const mock = schmock();
-    mock("GET /dynamic-binary", () => new Uint8Array([1, 2, 3]));
-
-    const response = await mock.handle("GET", "/dynamic-binary");
-
-    expect(response.headers["content-type"]).toBe("application/octet-stream");
-    expect(binaryBytes(response.body)).toEqual([1, 2, 3]);
-  });
-
-  it("detects binary in a status tuple", async () => {
-    const mock = schmock();
-    const bytes = new Uint8Array([4, 5, 6]);
-    mock(
-      "GET /tuple-binary",
-      () => [206, new DataView(bytes.buffer)] satisfies [number, unknown],
-    );
-
-    const response = await mock.handle("GET", "/tuple-binary");
-
-    expect(response.status).toBe(206);
-    expect(response.headers["content-type"]).toBe("application/octet-stream");
-    expect(binaryBytes(response.body)).toEqual([4, 5, 6]);
-  });
-
-  it("detects binary in a response object", () => {
-    const response = parseResponse(
-      { status: 206, body: new Uint8Array([7, 8]), headers: {} },
-      {},
-    );
-
-    expect(response.status).toBe(206);
-    expect(response.headers["content-type"]).toBe("application/octet-stream");
-    expect(binaryBytes(response.body)).toEqual([7, 8]);
-  });
-
-  it("preserves an explicit binary content type", async () => {
-    const mock = schmock();
-    mock("GET /image", () => new Uint8Array([137, 80, 78, 71]), {
-      contentType: "image/png",
-    });
-
-    const response = await mock.handle("GET", "/image");
-
-    expect(response.headers["content-type"]).toBe("image/png");
-    expect(binaryBytes(response.body)).toEqual([137, 80, 78, 71]);
-  });
-
-  it("preserves a tuple content-type header without adding a duplicate", () => {
-    const response = parseResponse(
-      [
-        200,
-        new Uint8Array([1]),
-        { "Content-Type": "application/custom-binary" },
-      ],
-      { contentType: "application/json" },
-    );
-
-    expect(response.headers).toEqual({
-      "Content-Type": "application/custom-binary",
-    });
-    expect(binaryBytes(response.body)).toEqual([1]);
-  });
-});
-
-describe("browser runtime compatibility", () => {
-  it("defines and serves object routes when Buffer is not available", async () => {
-    const originalBuffer = globalThis.Buffer;
-    Reflect.deleteProperty(globalThis, "Buffer");
-
-    try {
-      const mock = schmock();
-      mock("GET /browser", { runtime: "browser" });
-
-      const response = await mock.handle("GET", "/browser");
-      expect(response.status).toBe(200);
-      expect(response.body).toEqual({ runtime: "browser" });
-      expect(response.headers["content-type"]).toBe("application/json");
-    } finally {
-      globalThis.Buffer = originalBuffer;
-    }
-  });
-});

package/src/binary.ts

@@ -1,11 +0,0 @@
-/**
- * Browser-safe binary body detection.
- *
- * Every ArrayBuffer view is accepted, including DataView, typed arrays backed
- * by SharedArrayBuffer, and Node.js Buffer without referencing its global.
- */
-export function isBinaryBody(
-  value: unknown,
-): value is ArrayBuffer | ArrayBufferView {
-  return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
-}