@schmock/core 2.3.0 → 2.3.1

package/src/parser.test.ts

@@ -1,148 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseRouteKey } from "./parser";
-
-describe("parseRouteKey", () => {
-  describe("valid route keys", () => {
-    it("parses simple GET route", () => {
-      const result = parseRouteKey("GET /users");
-      expect(result).toEqual({
-        method: "GET",
-        path: "/users",
-        pattern: expect.any(RegExp),
-        params: [],
-      });
-    });
-
-    it("parses route with single parameter", () => {
-      const result = parseRouteKey("GET /users/:id");
-      expect(result).toEqual({
-        method: "GET",
-        path: "/users/:id",
-        pattern: expect.any(RegExp),
-        params: ["id"],
-      });
-    });
-
-    it("parses route with multiple parameters", () => {
-      const result = parseRouteKey(
-        "DELETE /api/posts/:postId/comments/:commentId",
-      );
-      expect(result).toEqual({
-        method: "DELETE",
-        path: "/api/posts/:postId/comments/:commentId",
-        pattern: expect.any(RegExp),
-        params: ["postId", "commentId"],
-      });
-    });
-
-    it("supports all HTTP methods", () => {
-      const methods = [
-        "GET",
-        "POST",
-        "PUT",
-        "DELETE",
-        "PATCH",
-        "HEAD",
-        "OPTIONS",
-      ] as const;
-
-      for (const method of methods) {
-        const result = parseRouteKey(`${method} /test`);
-        expect(result.method).toBe(method);
-      }
-    });
-
-    it("handles paths with namespace", () => {
-      const result = parseRouteKey("POST /api/v2/users");
-      expect(result).toEqual({
-        method: "POST",
-        path: "/api/v2/users",
-        pattern: expect.any(RegExp),
-        params: [],
-      });
-    });
-
-    it("creates correct regex pattern for simple path", () => {
-      const result = parseRouteKey("GET /users");
-      expect("/users").toMatch(result.pattern);
-      expect("/users/123").not.toMatch(result.pattern);
-    });
-
-    it("creates correct regex pattern with parameters", () => {
-      const result = parseRouteKey("GET /users/:id");
-      expect("/users/123").toMatch(result.pattern);
-      expect("/users/abc-def").toMatch(result.pattern);
-      expect("/users").not.toMatch(result.pattern);
-      expect("/users/").not.toMatch(result.pattern);
-      expect("/users/123/posts").not.toMatch(result.pattern);
-    });
-  });
-
-  describe("invalid route keys", () => {
-    it("throws on missing method", () => {
-      expect(() => parseRouteKey("/users")).toThrow("Invalid route key format");
-    });
-
-    it("throws on missing path", () => {
-      expect(() => parseRouteKey("GET")).toThrow("Invalid route key format");
-    });
-
-    it("throws on invalid method", () => {
-      expect(() => parseRouteKey("INVALID /users")).toThrow(
-        "Invalid route key format",
-      );
-    });
-
-    it("throws on lowercase method", () => {
-      expect(() => parseRouteKey("get /users")).toThrow(
-        "Invalid route key format",
-      );
-    });
-
-    it("throws on missing space", () => {
-      expect(() => parseRouteKey("GET/users")).toThrow(
-        "Invalid route key format",
-      );
-    });
-
-    it("throws on empty string", () => {
-      expect(() => parseRouteKey("")).toThrow("Invalid route key format");
-    });
-  });
-
-  describe("parameter extraction", () => {
-    it("extracts matched parameters", () => {
-      const route = parseRouteKey("GET /users/:userId/posts/:postId");
-      const match = "/users/123/posts/456".match(route.pattern);
-
-      expect(match).toBeTruthy();
-      expect(match?.[1]).toBe("123");
-      expect(match?.[2]).toBe("456");
-    });
-
-    it("handles special characters in parameters", () => {
-      const route = parseRouteKey("GET /files/:filename");
-      const match = "/files/report-2023.pdf".match(route.pattern);
-
-      expect(match).toBeTruthy();
-      expect(match?.[1]).toBe("report-2023.pdf");
-    });
-
-    it("stops the param name at a literal '.' suffix and escapes the dot", () => {
-      const route = parseRouteKey("GET /files/:name.json");
-
-      expect(route.params).toEqual(["name"]);
-      expect("/files/report.json".match(route.pattern)?.[1]).toBe("report");
-      expect("/files/report.json2".match(route.pattern)).toBeNull();
-      expect("/files/reportXjson".match(route.pattern)).toBeNull();
-    });
-
-    it("treats parens around params as literal characters", () => {
-      const route = parseRouteKey("GET /items/(:id)");
-
-      expect(route.params).toEqual(["id"]);
-      expect("/items/(42)".match(route.pattern)?.[1]).toBe("42");
-      expect("/items/42".match(route.pattern)).toBeNull();
-    });
-  });
-});

package/src/parser.ts

@@ -1,64 +0,0 @@
-import { toHttpMethod } from "./constants.js";
-import { RouteParseError } from "./errors.js";
-import type { HttpMethod } from "./types.js";
-
-export interface ParsedRoute {
-  method: HttpMethod;
-  path: string;
-  pattern: RegExp;
-  params: string[];
-}
-
-/**
- * Parse 'METHOD /path' route key format
- *
- * Design note: We validate the format strictly to catch typos early.
- * The 'METHOD /path' format was chosen for its readability and
- * similarity to API documentation formats.
- *
- * @example
- * parseRouteKey('GET /users/:id')
- * // => { method: 'GET', path: '/users/:id', pattern: /^\/users\/([^/]+)$/, params: ['id'] }
- */
-export function parseRouteKey(routeKey: string): ParsedRoute {
-  const match = routeKey.match(
-    /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS) (.+)$/,
-  );
-
-  if (!match) {
-    throw new RouteParseError(
-      routeKey,
-      'Expected format: "METHOD /path" (e.g., "GET /users")',
-    );
-  }
-
-  const [, method, path] = match;
-
-  // Parameter names are restricted to [A-Za-z0-9_-] so that surrounding
-  // literals (".json", brackets, parens, etc.) terminate the name and can
-  // be escaped without bleeding into the parameter regex. Build the
-  // pattern by splitting the path on the param marker, escaping each
-  // literal segment, then substituting the capture group for each :name.
-  const params: string[] = [];
-
-  const regexPath = path
-    .split(/(:[a-zA-Z0-9_-]+)/g)
-    .map((segment) => {
-      const paramMatch = segment.match(/^:([a-zA-Z0-9_-]+)$/);
-      if (paramMatch) {
-        params.push(paramMatch[1]);
-        return "([^/]+)";
-      }
-      return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    })
-    .join("");
-
-  const pattern = new RegExp(`^${regexPath}$`);
-
-  return {
-    method: toHttpMethod(method),
-    path,
-    pattern,
-    params,
-  };
-}

package/src/plugin-pipeline.ts

@@ -1,208 +0,0 @@
-import { errorMessage, PluginError } from "./errors.js";
-
-/** Structural typing — DebugLogger satisfies this without an import */
-interface PipelineLogger {
-  log(category: string, message: string, data?: unknown): void;
-}
-
-interface PipelineResult {
-  context: Schmock.PluginContext;
-  response?: unknown;
-  recoveredFromError?: boolean;
-  requestShortCircuited?: boolean;
-}
-
-function isPluginResult(value: unknown): value is Schmock.PluginResult {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "context" in value &&
-    typeof value.context === "object" &&
-    value.context !== null
-  );
-}
-
-async function recoverPluginError(
-  plugins: Schmock.Plugin[],
-  startIndex: number,
-  error: unknown,
-  context: Schmock.PluginContext,
-  logger: PipelineLogger,
-): Promise<
-  { handled: true; response: unknown } | { handled: false; error: Error }
-> {
-  let currentError =
-    error instanceof Error ? error : new Error(errorMessage(error));
-
-  for (let index = startIndex; index < plugins.length; index += 1) {
-    const plugin = plugins[index];
-    if (!plugin.onError) continue;
-
-    try {
-      const errorResult = await plugin.onError(currentError, context);
-      if (errorResult instanceof Error) {
-        currentError = errorResult;
-        continue;
-      }
-      if (errorResult !== undefined) {
-        logger.log("pipeline", `Plugin ${plugin.name} handled error`);
-        return { handled: true, response: errorResult };
-      }
-    } catch (hookError) {
-      currentError =
-        hookError instanceof Error
-          ? hookError
-          : new Error(errorMessage(hookError));
-      logger.log(
-        "pipeline",
-        `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`,
-      );
-    }
-  }
-
-  return { handled: false, error: currentError };
-}
-
-/** Run request guards before route code is allowed to execute. */
-export async function runPluginBeforeRequest(
-  plugins: Schmock.Plugin[],
-  context: Schmock.PluginContext,
-  logger: PipelineLogger,
-): Promise<PipelineResult> {
-  let currentContext = context;
-
-  for (let index = 0; index < plugins.length; index += 1) {
-    const plugin = plugins[index];
-    if (!plugin.beforeRequest) continue;
-
-    logger.log("pipeline", `Running beforeRequest: ${plugin.name}`);
-    try {
-      const result = await plugin.beforeRequest(currentContext);
-      if (result === undefined) continue;
-      if (!isPluginResult(result)) {
-        throw new Error(`Plugin ${plugin.name} didn't return valid result`);
-      }
-
-      currentContext = result.context;
-      if (result.response !== undefined) {
-        logger.log("pipeline", `Plugin ${plugin.name} rejected request`);
-        return {
-          context: currentContext,
-          response: result.response,
-          requestShortCircuited: true,
-        };
-      }
-    } catch (error) {
-      logger.log(
-        "pipeline",
-        `Plugin ${plugin.name} beforeRequest failed: ${errorMessage(error)}`,
-      );
-      const recovery = await recoverPluginError(
-        plugins,
-        index,
-        error,
-        currentContext,
-        logger,
-      );
-      if (recovery.handled) {
-        return {
-          context: currentContext,
-          response: recovery.response,
-          recoveredFromError: true,
-          requestShortCircuited: true,
-        };
-      }
-      throw new PluginError(plugin.name, recovery.error);
-    }
-  }
-
-  return { context: currentContext };
-}
-
-/** Give pipeline error handlers a chance to recover a route-generator error. */
-export async function recoverGeneratorError(
-  plugins: Schmock.Plugin[],
-  context: Schmock.PluginContext,
-  error: unknown,
-  logger: PipelineLogger,
-): Promise<PipelineResult> {
-  const recovery = await recoverPluginError(plugins, 0, error, context, logger);
-  if (recovery.handled) {
-    return {
-      context,
-      response: recovery.response,
-      recoveredFromError: true,
-    };
-  }
-  throw recovery.error;
-}
-
-/**
- * Run all registered plugins in sequence
- * First plugin to set response becomes generator, subsequent plugins transform
- * Handles plugin errors via onError hooks
- */
-export async function runPluginPipeline(
-  plugins: Schmock.Plugin[],
-  context: Schmock.PluginContext,
-  initialResponse: unknown,
-  logger: PipelineLogger,
-): Promise<PipelineResult> {
-  let currentContext = context;
-  let response: unknown = initialResponse;
-
-  logger.log(
-    "pipeline",
-    `Running plugin pipeline for ${plugins.length} plugins`,
-  );
-
-  for (let index = 0; index < plugins.length; index += 1) {
-    const plugin = plugins[index];
-    logger.log("pipeline", `Processing plugin: ${plugin.name}`);
-
-    try {
-      const result = await plugin.process(currentContext, response);
-
-      if (!isPluginResult(result)) {
-        throw new Error(`Plugin ${plugin.name} didn't return valid result`);
-      }
-
-      currentContext = result.context;
-
-      // First plugin to set response becomes the generator
-      if (
-        result.response !== undefined &&
-        (response === undefined || response === null)
-      ) {
-        logger.log("pipeline", `Plugin ${plugin.name} generated response`);
-        response = result.response;
-      } else if (result.response !== undefined && response !== undefined) {
-        logger.log("pipeline", `Plugin ${plugin.name} transformed response`);
-        response = result.response;
-      }
-    } catch (error) {
-      logger.log(
-        "pipeline",
-        `Plugin ${plugin.name} failed: ${errorMessage(error)}`,
-      );
-
-      const recovery = await recoverPluginError(
-        plugins,
-        index,
-        error,
-        currentContext,
-        logger,
-      );
-      if (recovery.handled) {
-        return {
-          context: currentContext,
-          response: recovery.response,
-          recoveredFromError: true,
-        };
-      }
-      throw new PluginError(plugin.name, recovery.error);
-    }
-  }
-
-  return { context: currentContext, response };
-}