@schmock/core 2.3.0 → 2.4.0

package/src/factory.test.ts

@@ -1,133 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { schmock } from "./index";
-
-describe("schmock factory function", () => {
-  describe("factory behavior", () => {
-    it("creates callable mock instance with no config", () => {
-      const mock = schmock();
-
-      expect(typeof mock).toBe("function");
-      expect(typeof mock.handle).toBe("function");
-      expect(typeof mock.pipe).toBe("function");
-    });
-
-    it("creates callable mock instance with config", () => {
-      const config = { debug: true, namespace: "/api" };
-      const mock = schmock(config);
-
-      expect(typeof mock).toBe("function");
-      expect(typeof mock.handle).toBe("function");
-      expect(typeof mock.pipe).toBe("function");
-    });
-
-    it("supports method chaining from factory call", () => {
-      const mock = schmock();
-      const result = mock("GET /test", "response");
-
-      expect(result).toBe(mock); // Should return same instance for chaining
-    });
-
-    it("supports plugin chaining", () => {
-      const mock = schmock();
-      const plugin = {
-        name: "test",
-        process: (ctx: any, res: any) => ({ context: ctx, response: res }),
-      };
-      const result = mock.pipe(plugin);
-
-      expect(result).toBe(mock); // Should return same instance for chaining
-    });
-  });
-
-  describe("callable instance behavior", () => {
-    it("defines routes when called as function", async () => {
-      const mock = schmock();
-      mock("GET /test", "hello");
-
-      const response = await mock.handle("GET", "/test");
-      expect(response.body).toBe("hello");
-    });
-
-    it("allows method chaining after route definition", async () => {
-      const mock = schmock();
-      const plugin = {
-        name: "test",
-        process: (ctx: any, res: any) => ({ context: ctx, response: res }),
-      };
-
-      mock("GET /test", "hello").pipe(plugin);
-
-      const response = await mock.handle("GET", "/test");
-      expect(response.body).toBe("hello");
-    });
-
-    it("passes config to route definition", async () => {
-      const mock = schmock();
-      mock("GET /test", { data: "test" }, { contentType: "text/plain" });
-
-      const response = await mock.handle("GET", "/test");
-      expect(response.headers["content-type"]).toBe("text/plain");
-      expect(response.body).toBe('{"data":"test"}'); // Stringified because contentType is text/plain
-    });
-  });
-
-  describe("binding and method preservation", () => {
-    it("preserves handle method binding", async () => {
-      const mock = schmock();
-      mock("GET /test", "response");
-
-      const handleMethod = mock.handle;
-      const response = await handleMethod("GET", "/test");
-
-      expect(response.body).toBe("response");
-    });
-
-    it("allows destructuring of methods", async () => {
-      const mock = schmock();
-      mock("GET /test", "response");
-
-      const { handle } = mock;
-      const response = await handle("GET", "/test");
-
-      expect(response.body).toBe("response");
-    });
-
-    it("pipes maintain chain references", () => {
-      const mock = schmock();
-      const plugin1 = {
-        name: "plugin1",
-        process: (ctx: any, res: any) => ({ context: ctx, response: res }),
-      };
-      const plugin2 = {
-        name: "plugin2",
-        process: (ctx: any, res: any) => ({ context: ctx, response: res }),
-      };
-
-      const chain = mock.pipe(plugin1).pipe(plugin2);
-
-      expect(chain).toBe(mock);
-    });
-  });
-
-  describe("type compatibility", () => {
-    it("works with TypeScript function signature", () => {
-      // Test that the factory function matches expected TypeScript types
-      const mock = schmock({ debug: false });
-      mock("GET /users", () => [{ id: 1 }], {
-        contentType: "application/json",
-      });
-
-      expect(typeof mock).toBe("function");
-    });
-
-    it("handles optional config parameter", () => {
-      const mock1 = schmock();
-      const mock2 = schmock({});
-      const mock3 = schmock({ debug: true });
-
-      expect(typeof mock1).toBe("function");
-      expect(typeof mock2).toBe("function");
-      expect(typeof mock3).toBe("function");
-    });
-  });
-});

package/src/helpers.test.ts

@@ -1,147 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  badRequest,
-  created,
-  forbidden,
-  noContent,
-  notFound,
-  paginate,
-  serverError,
-  unauthorized,
-} from "./helpers.js";
-
-describe("notFound", () => {
-  it("returns 404 with default message", () => {
-    expect(notFound()).toEqual([404, { message: "Not Found" }]);
-  });
-  it("returns 404 with custom string message", () => {
-    expect(notFound("User not found")).toEqual([
-      404,
-      { message: "User not found" },
-    ]);
-  });
-  it("returns 404 with custom object", () => {
-    expect(notFound({ code: "NOT_FOUND", detail: "gone" })).toEqual([
-      404,
-      { code: "NOT_FOUND", detail: "gone" },
-    ]);
-  });
-});
-
-describe("badRequest", () => {
-  it("returns 400 with default message", () => {
-    expect(badRequest()).toEqual([400, { message: "Bad Request" }]);
-  });
-  it("returns 400 with custom string", () => {
-    expect(badRequest("Invalid email")).toEqual([
-      400,
-      { message: "Invalid email" },
-    ]);
-  });
-});
-
-describe("unauthorized", () => {
-  it("returns 401 with default message", () => {
-    expect(unauthorized()).toEqual([401, { message: "Unauthorized" }]);
-  });
-});
-
-describe("forbidden", () => {
-  it("returns 403 with default message", () => {
-    expect(forbidden()).toEqual([403, { message: "Forbidden" }]);
-  });
-});
-
-describe("serverError", () => {
-  it("returns 500 with default message", () => {
-    expect(serverError()).toEqual([500, { message: "Internal Server Error" }]);
-  });
-});
-
-describe("created", () => {
-  it("returns 201 with body", () => {
-    expect(created({ id: 1, name: "John" })).toEqual([
-      201,
-      { id: 1, name: "John" },
-    ]);
-  });
-});
-
-describe("noContent", () => {
-  it("returns 204 with null body", () => {
-    expect(noContent()).toEqual([204, null]);
-  });
-});
-
-describe("paginate", () => {
-  const items = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
-
-  it("returns first page with default pageSize", () => {
-    const result = paginate(items);
-    expect(result).toEqual({
-      data: items,
-      page: 1,
-      pageSize: 10,
-      total: 5,
-      totalPages: 1,
-    });
-  });
-
-  it("paginates correctly with custom options", () => {
-    const result = paginate(items, { page: 2, pageSize: 2 });
-    expect(result).toEqual({
-      data: [{ id: 3 }, { id: 4 }],
-      page: 2,
-      pageSize: 2,
-      total: 5,
-      totalPages: 3,
-    });
-  });
-
-  it("returns empty data for page beyond range", () => {
-    const result = paginate(items, { page: 10, pageSize: 2 });
-    expect(result.data).toEqual([]);
-    expect(result.total).toBe(5);
-  });
-
-  it("page=0 falls back to page 1 (falsy default)", () => {
-    const result = paginate(items, { page: 0, pageSize: 2 });
-    // page=0 is falsy, so options.page || 1 => 1
-    expect(result.page).toBe(1);
-    expect(result.data).toEqual([{ id: 1 }, { id: 2 }]);
-  });
-
-  it("pageSize=0 falls back to default 10 (falsy default)", () => {
-    const result = paginate(items, { pageSize: 0 });
-    // pageSize=0 is falsy, so options.pageSize || 10 => 10
-    expect(result.pageSize).toBe(10);
-    expect(result.data).toEqual(items);
-  });
-
-  it("handles empty array", () => {
-    const result = paginate([], { page: 1, pageSize: 5 });
-    expect(result).toEqual({
-      data: [],
-      page: 1,
-      pageSize: 5,
-      total: 0,
-      totalPages: 0,
-    });
-  });
-
-  it("negative page produces empty data (start index < 0)", () => {
-    const result = paginate(items, { page: -1, pageSize: 2 });
-    // (page - 1) * pageSize = (-1 - 1) * 2 = -4
-    // items.slice(-4, -2) => items from index 1 to 3
-    expect(result.page).toBe(-1);
-    expect(result.pageSize).toBe(2);
-    expect(result.total).toBe(5);
-  });
-
-  it("negative pageSize returns empty data", () => {
-    const result = paginate(items, { page: 1, pageSize: -5 });
-    // start = 0, end = 0 + (-5) = -5 => items.slice(0, -5) => []
-    expect(result.data).toEqual([]);
-    expect(result.pageSize).toBe(-5);
-  });
-});

package/src/helpers.ts

@@ -1,58 +0,0 @@
-/// <reference path="../schmock.d.ts" />
-
-export function notFound(
-  message: string | object = "Not Found",
-): [number, object] {
-  const body = typeof message === "string" ? { message } : message;
-  return [404, body];
-}
-
-export function badRequest(
-  message: string | object = "Bad Request",
-): [number, object] {
-  const body = typeof message === "string" ? { message } : message;
-  return [400, body];
-}
-
-export function unauthorized(
-  message: string | object = "Unauthorized",
-): [number, object] {
-  const body = typeof message === "string" ? { message } : message;
-  return [401, body];
-}
-
-export function forbidden(
-  message: string | object = "Forbidden",
-): [number, object] {
-  const body = typeof message === "string" ? { message } : message;
-  return [403, body];
-}
-
-export function serverError(
-  message: string | object = "Internal Server Error",
-): [number, object] {
-  const body = typeof message === "string" ? { message } : message;
-  return [500, body];
-}
-
-export function created(body: object): [number, object] {
-  return [201, body];
-}
-
-export function noContent(): [number, null] {
-  return [204, null];
-}
-
-export function paginate<T>(
-  items: T[],
-  options: Schmock.PaginateOptions = {},
-): Schmock.PaginatedResponse<T> {
-  const page = options.page || 1;
-  const pageSize = options.pageSize || 10;
-  const total = items.length;
-  const totalPages = Math.ceil(total / pageSize);
-  const start = (page - 1) * pageSize;
-  const end = start + pageSize;
-  const data = items.slice(start, end);
-  return { data, page, pageSize, total, totalPages };
-}

package/src/http-helpers.test.ts

@@ -1,39 +0,0 @@
-import { PassThrough } from "node:stream";
-import { describe, expect, it } from "vitest";
-import { collectBody } from "./http-helpers.js";
-
-function bodyStream(body: Buffer): PassThrough {
-  const stream = new PassThrough();
-  stream.end(body);
-  return stream;
-}
-
-describe("collectBody size limits", () => {
-  it("accepts a body exactly at the configured limit", async () => {
-    const body = Buffer.from("12345");
-    await expect(collectBody(bodyStream(body), {}, body.length)).resolves.toBe(
-      "12345",
-    );
-  });
-
-  it("accepts and parses JSON below the configured limit", async () => {
-    const body = Buffer.from('{"ok":true}');
-    await expect(
-      collectBody(
-        bodyStream(body),
-        { "content-type": "application/json" },
-        body.length + 1,
-      ),
-    ).resolves.toEqual({ ok: true });
-  });
-
-  it("rejects a body above the configured limit with status 413", async () => {
-    const body = Buffer.from("123456");
-    await expect(
-      collectBody(bodyStream(body), {}, body.length - 1),
-    ).rejects.toMatchObject({
-      message: "Request body too large",
-      status: 413,
-    });
-  });
-});

package/src/http-helpers.ts

@@ -1,149 +0,0 @@
-import type { ServerResponse } from "node:http";
-import { isBinaryBody } from "./binary.js";
-
-interface RequestWithHeaders {
-  readonly headers: {
-    readonly [header: string]: string | string[] | undefined;
-  };
-}
-
-interface BodyReadable {
-  on(event: "error", listener: (error: Error) => void): this;
-  on(event: "data", listener: (chunk: Buffer) => void): this;
-  on(event: "end", listener: () => void): this;
-  destroy(error?: Error): this;
-}
-
-/**
- * Convert Node.js IncomingMessage headers to a flat Record<string, string>.
- * Drops array-valued headers (keeps only string values).
- */
-export function parseNodeHeaders(
-  req: RequestWithHeaders,
-): Record<string, string> {
-  const headers: Record<string, string> = {};
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (typeof value === "string") {
-      headers[key] = value;
-    }
-  }
-  return headers;
-}
-
-/**
- * Extract query parameters from a URL as a flat Record<string, string>.
- */
-export function parseNodeQuery(url: URL): Record<string, string> {
-  const query: Record<string, string> = {};
-  url.searchParams.forEach((value, key) => {
-    query[key] = value;
-  });
-  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: BodyReadable,
-  headers: Record<string, string>,
-  maxBodySize = DEFAULT_MAX_BODY_SIZE,
-): Promise<unknown> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    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) {
-        resolve(undefined);
-        return;
-      }
-      const contentType = headers["content-type"] ?? "";
-      if (contentType.includes("json")) {
-        try {
-          resolve(JSON.parse(raw));
-        } catch {
-          resolve(raw);
-        }
-      } else {
-        resolve(raw);
-      }
-    });
-  });
-}
-
-/**
- * Write a Schmock Response to a Node.js ServerResponse.
- * Serializes non-string bodies as JSON and sets content-type when missing.
- */
-export function writeSchmockResponse(
-  res: ServerResponse,
-  response: Schmock.Response,
-  extraHeaders?: Record<string, string>,
-): void {
-  const responseHeaders: Record<string, string> = {
-    ...response.headers,
-    ...extraHeaders,
-  };
-
-  const hasContentType = Object.keys(responseHeaders).some(
-    (header) => header.toLowerCase() === "content-type",
-  );
-
-  if (
-    !hasContentType &&
-    response.body !== undefined &&
-    isBinaryBody(response.body)
-  ) {
-    responseHeaders["content-type"] = "application/octet-stream";
-  } else if (
-    !hasContentType &&
-    response.body !== undefined &&
-    typeof response.body !== "string"
-  ) {
-    responseHeaders["content-type"] = "application/json";
-  }
-
-  let responseBody: string | Uint8Array | undefined;
-  if (response.body === undefined) {
-    responseBody = undefined;
-  } else if (typeof response.body === "string") {
-    responseBody = response.body;
-  } else if (response.body instanceof ArrayBuffer) {
-    responseBody = new Uint8Array(response.body);
-  } else if (ArrayBuffer.isView(response.body)) {
-    responseBody = new Uint8Array(
-      response.body.buffer,
-      response.body.byteOffset,
-      response.body.byteLength,
-    );
-  } else {
-    responseBody = JSON.stringify(response.body);
-  }
-
-  res.writeHead(response.status, responseHeaders);
-  res.end(responseBody);
-}

package/src/index.ts

@@ -1,152 +0,0 @@
-import { CallableMockInstance } from "./builder.js";
-
-/**
- * Create a new Schmock mock instance with callable API.
- *
- * @example
- * ```typescript
- * // New callable API (default)
- * const mock = schmock({ debug: true })
- * mock('GET /users', () => [{ id: 1, name: 'John' }])
- *   .pipe(authPlugin())
- *
- * const response = await mock.handle('GET', '/users')
- * ```
- *
- * @example
- * ```typescript
- * // Simple usage with defaults
- * const mock = schmock()
- * mock('GET /users', [{ id: 1, name: 'John' }])
- * ```
- *
- * @param config Optional global configuration
- * @returns A callable mock instance
- */
-export function schmock(
-  config?: Schmock.GlobalConfig,
-): Schmock.CallableMockInstance {
-  // Always use new callable API
-  const instance = new CallableMockInstance(config || {});
-
-  // Callable proxy: a function with attached methods
-  const callableInstance: Schmock.CallableMockInstance = Object.assign(
-    (
-      route: Schmock.RouteKey,
-      generator: Schmock.Generator,
-      routeConfig: Schmock.RouteConfig = {},
-    ) => {
-      instance.defineRoute(route, generator, routeConfig);
-      return callableInstance;
-    },
-    {
-      pipe: (plugin: Schmock.Plugin) => {
-        instance.pipe(plugin);
-        return callableInstance;
-      },
-      handle: instance.handle.bind(instance),
-      history: instance.history.bind(instance),
-      called: instance.called.bind(instance),
-      callCount: instance.callCount.bind(instance),
-      lastRequest: instance.lastRequest.bind(instance),
-      reset: instance.reset.bind(instance),
-      resetHistory: instance.resetHistory.bind(instance),
-      resetState: instance.resetState.bind(instance),
-      on<E extends Schmock.SchmockEvent>(
-        event: E,
-        listener: (data: Schmock.SchmockEventMap[E]) => void,
-      ) {
-        instance.on(event, listener);
-        return callableInstance;
-      },
-      off<E extends Schmock.SchmockEvent>(
-        event: E,
-        listener: (data: Schmock.SchmockEventMap[E]) => void,
-      ) {
-        instance.off(event, listener);
-        return callableInstance;
-      },
-      getRoutes: instance.getRoutes.bind(instance),
-      getState: instance.getState.bind(instance),
-      listen: instance.listen.bind(instance),
-      close: instance.close.bind(instance),
-      intercept: (options?: Schmock.InterceptOptions) =>
-        instance.intercept(options),
-    },
-  );
-
-  instance.setCallableRef(callableInstance);
-
-  return callableInstance;
-}
-
-export { isBinaryBody } from "./binary.js";
-// Re-export constants and utilities
-export {
-  HTTP_METHODS,
-  isHttpMethod,
-  isRouteNotFound,
-  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 response helpers
-export {
-  badRequest,
-  created,
-  forbidden,
-  noContent,
-  notFound,
-  paginate,
-  serverError,
-  unauthorized,
-} from "./helpers.js";
-// Re-export HTTP server helpers
-export {
-  collectBody,
-  parseNodeHeaders,
-  parseNodeQuery,
-  writeSchmockResponse,
-} from "./http-helpers.js";
-// Re-export types
-// Re-export interceptor
-export { createFetchInterceptor } from "./interceptor.js";
-// Re-export types
-export type {
-  AdapterRequest,
-  AdapterResponse,
-  CallableMockInstance,
-  Generator,
-  GeneratorFunction,
-  GlobalConfig,
-  HttpMethod,
-  InterceptHandle,
-  InterceptOptions,
-  Plugin,
-  PluginContext,
-  PluginResult,
-  RequestContext,
-  RequestOptions,
-  RequestRecord,
-  Response,
-  ResponseBody,
-  ResponseResult,
-  RouteConfig,
-  RouteInfo,
-  RouteKey,
-  ServerInfo,
-  StaticData,
-} from "./types.js";