@schmock/core 2.2.3 → 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,103 +0,0 @@
-import { isStatusTuple } from "./constants.js";
-import { errorMessage, PluginError } from "./errors.js";
-
-/** Structural typing — DebugLogger satisfies this without an import */
-interface PipelineLogger {
-  log(category: string, message: string, data?: unknown): void;
-}
-
-/**
- * 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<{ context: Schmock.PluginContext; response?: unknown }> {
-  let currentContext = context;
-  let response: unknown = initialResponse;
-
-  logger.log(
-    "pipeline",
-    `Running plugin pipeline for ${plugins.length} plugins`,
-  );
-
-  for (const plugin of plugins) {
-    logger.log("pipeline", `Processing plugin: ${plugin.name}`);
-
-    try {
-      const result = await plugin.process(currentContext, response);
-
-      if (!result?.context) {
-        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)}`,
-      );
-
-      // Try error handling if plugin has onError hook
-      if (plugin.onError) {
-        try {
-          const pluginError =
-            error instanceof Error ? error : new Error(errorMessage(error));
-          const errorResult = await plugin.onError(pluginError, currentContext);
-          if (errorResult) {
-            logger.log("pipeline", `Plugin ${plugin.name} handled error`);
-
-            // Error return → transform the thrown error
-            if (errorResult instanceof Error) {
-              throw new PluginError(plugin.name, errorResult);
-            }
-
-            // ResponseResult return → recover, stop pipeline
-            // Accept both object-with-status and status tuple [code, body] / [code, body, headers]
-            if (
-              isStatusTuple(errorResult) ||
-              (typeof errorResult === "object" &&
-                errorResult !== null &&
-                "status" in errorResult)
-            ) {
-              response = errorResult;
-              break;
-            }
-          }
-          // void/falsy return → propagate original error below
-        } catch (hookError) {
-          // If the hook itself threw (including our PluginError above), re-throw it
-          if (hookError instanceof PluginError) {
-            throw hookError;
-          }
-          logger.log(
-            "pipeline",
-            `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`,
-          );
-        }
-      }
-
-      const cause =
-        error instanceof Error ? error : new Error(errorMessage(error));
-      throw new PluginError(plugin.name, cause);
-    }
-  }
-
-  return { context: currentContext, response };
-}