@schmock/core 1.0.4 → 1.1.0

package/dist/builder.d.ts

@@ -1,4 +1,3 @@
-import type { Generator, GlobalConfig, HttpMethod, Plugin, RequestOptions, Response, RouteConfig, RouteKey } from "./types.js";
 /**
  * Callable mock instance that implements the new API.
  *
@@ -7,12 +6,21 @@ import type { Generator, GlobalConfig, HttpMethod, Plugin, RequestOptions, Respo
 export declare class CallableMockInstance {
     private globalConfig;
     private routes;
+    private staticRoutes;
     private plugins;
     private logger;
-    constructor(globalConfig?: GlobalConfig);
-    defineRoute(route: RouteKey, generator: Generator, config: RouteConfig): this;
-    pipe(plugin: Plugin): this;
-    handle(method: HttpMethod, path: string, options?: RequestOptions): Promise<Response>;
+    private requestHistory;
+    constructor(globalConfig?: Schmock.GlobalConfig);
+    defineRoute(route: Schmock.RouteKey, generator: Schmock.Generator, config: Schmock.RouteConfig): this;
+    pipe(plugin: Schmock.Plugin): this;
+    history(method?: Schmock.HttpMethod, path?: string): Schmock.RequestRecord[];
+    called(method?: Schmock.HttpMethod, path?: string): boolean;
+    callCount(method?: Schmock.HttpMethod, path?: string): number;
+    lastRequest(method?: Schmock.HttpMethod, path?: string): Schmock.RequestRecord | undefined;
+    reset(): void;
+    resetHistory(): void;
+    resetState(): void;
+    handle(method: Schmock.HttpMethod, path: string, options?: Schmock.RequestOptions): Promise<Schmock.Response>;
     /**
      * Apply configured response delay
      * Supports both fixed delays and random delays within a range

package/dist/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,SAAS,EAET,YAAY,EACZ,UAAU,EACV,MAAM,EAGN,cAAc,EACd,QAAQ,EACR,WAAW,EACX,QAAQ,EACT,MAAM,YAAY,CAAC;AA4CpB;;;;GAIG;AACH,qBAAa,oBAAoB;IAKnB,OAAO,CAAC,YAAY;IAJhC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,MAAM,CAAc;gBAER,YAAY,GAAE,YAAiB;IAanD,WAAW,CACT,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,WAAW,GAClB,IAAI;IAuEP,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAepB,MAAM,CACV,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,QAAQ,CAAC;IAiLpB;;;;OAIG;YACW,UAAU;IAcxB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IA0DrB;;;;;;;;;;OAUG;YACW,iBAAiB;IAuF/B;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;IA6BjB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;CActB"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAyEA;;;;GAIG;AACH,qBAAa,oBAAoB;IAOnB,OAAO,CAAC,YAAY;IANhC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,cAAc,CAA+B;gBAEjC,YAAY,GAAE,OAAO,CAAC,YAAiB;IAa3D,WAAW,CACT,KAAK,EAAE,OAAO,CAAC,QAAQ,EACvB,SAAS,EAAE,OAAO,CAAC,SAAS,EAC5B,MAAM,EAAE,OAAO,CAAC,WAAW,GAC1B,IAAI;IAqFP,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI;IAiBlC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE;IAS5E,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAS3D,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IAS7D,WAAW,CACT,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAC3B,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,GAAG,SAAS;IAYpC,KAAK,IAAI,IAAI;IAab,YAAY,IAAI,IAAI;IAKpB,UAAU,IAAI,IAAI;IASZ,MAAM,CACV,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,GAC/B,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IAoL5B;;;;OAIG;YACW,UAAU;IAcxB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAwDrB;;;;;;;;;;OAUG;YACW,iBAAiB;IAqG/B;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;IA0BjB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;CActB"}

package/dist/builder.js

@@ -1,5 +1,8 @@
 import { PluginError, RouteDefinitionError, RouteNotFoundError, SchmockError, } from "./errors.js";
 import { parseRouteKey } from "./parser.js";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : "Unknown error";
+}
 /**
  * Debug logger that respects debug mode configuration
  */
@@ -31,6 +34,15 @@ class DebugLogger {
         console.timeEnd(`[SCHMOCK] ${label}`);
     }
 }
+function isGeneratorFunction(gen) {
+    return typeof gen === "function";
+}
+function isResponseObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "status" in value &&
+        "body" in value);
+}
 /**
  * Callable mock instance that implements the new API.
  *
@@ -39,8 +51,10 @@ class DebugLogger {
 export class CallableMockInstance {
     globalConfig;
     routes = [];
+    staticRoutes = new Map();
     plugins = [];
     logger;
+    requestHistory = [];
     constructor(globalConfig = {}) {
         this.globalConfig = globalConfig;
         this.logger = new DebugLogger(globalConfig.debug || false);
@@ -103,6 +117,17 @@ export class CallableMockInstance {
             config,
         };
         this.routes.push(compiledRoute);
+        // Store static routes (no params) in Map for O(1) lookup
+        // Only store the first registration — "first registration wins" semantics
+        if (parsed.params.length === 0) {
+            const normalizedPath = parsed.path.endsWith("/") && parsed.path !== "/"
+                ? parsed.path.slice(0, -1)
+                : parsed.path;
+            const key = `${parsed.method} ${normalizedPath}`;
+            if (!this.staticRoutes.has(key)) {
+                this.staticRoutes.set(key, compiledRoute);
+            }
+        }
         this.logger.log("route", `Route defined: ${route}`, {
             contentType: config.contentType,
             generatorType: typeof generator,
@@ -120,8 +145,59 @@ export class CallableMockInstance {
         });
         return this;
     }
+    // ===== Request Spy / History API =====
+    history(method, path) {
+        if (method && path) {
+            return this.requestHistory.filter((r) => r.method === method && r.path === path);
+        }
+        return [...this.requestHistory];
+    }
+    called(method, path) {
+        if (method && path) {
+            return this.requestHistory.some((r) => r.method === method && r.path === path);
+        }
+        return this.requestHistory.length > 0;
+    }
+    callCount(method, path) {
+        if (method && path) {
+            return this.requestHistory.filter((r) => r.method === method && r.path === path).length;
+        }
+        return this.requestHistory.length;
+    }
+    lastRequest(method, path) {
+        if (method && path) {
+            const filtered = this.requestHistory.filter((r) => r.method === method && r.path === path);
+            return filtered[filtered.length - 1];
+        }
+        return this.requestHistory[this.requestHistory.length - 1];
+    }
+    // ===== Reset / Lifecycle =====
+    reset() {
+        this.routes = [];
+        this.staticRoutes.clear();
+        this.plugins = [];
+        this.requestHistory = [];
+        if (this.globalConfig.state) {
+            for (const key of Object.keys(this.globalConfig.state)) {
+                delete this.globalConfig.state[key];
+            }
+        }
+        this.logger.log("lifecycle", "Mock fully reset");
+    }
+    resetHistory() {
+        this.requestHistory = [];
+        this.logger.log("lifecycle", "Request history cleared");
+    }
+    resetState() {
+        if (this.globalConfig.state) {
+            for (const key of Object.keys(this.globalConfig.state)) {
+                delete this.globalConfig.state[key];
+            }
+        }
+        this.logger.log("lifecycle", "State cleared");
+    }
     async handle(method, path, options) {
-        const requestId = Math.random().toString(36).substring(2, 10) || "00000000";
+        const requestId = crypto.randomUUID();
         this.logger.log("request", `[${requestId}] ${method} ${path}`, {
             headers: options?.headers,
             query: options?.query,
@@ -131,40 +207,30 @@ export class CallableMockInstance {
         try {
             // Apply namespace if configured
             let requestPath = path;
-            if (this.globalConfig.namespace) {
-                // Normalize namespace to handle edge cases
-                const namespace = this.globalConfig.namespace;
-                if (namespace === "/") {
-                    // Root namespace means no transformation needed
-                    requestPath = path;
-                }
-                else {
-                    // Handle namespace without leading slash by normalizing both namespace and path
-                    const normalizedNamespace = namespace.startsWith("/")
-                        ? namespace
-                        : `/${namespace}`;
-                    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-                    // Remove trailing slash from namespace unless it's root
-                    const finalNamespace = normalizedNamespace.endsWith("/") && normalizedNamespace !== "/"
-                        ? normalizedNamespace.slice(0, -1)
-                        : normalizedNamespace;
-                    if (!normalizedPath.startsWith(finalNamespace)) {
-                        this.logger.log("route", `[${requestId}] Path doesn't match namespace ${namespace}`);
-                        const error = new RouteNotFoundError(method, path);
-                        const response = {
-                            status: 404,
-                            body: { error: error.message, code: error.code },
-                            headers: {},
-                        };
-                        this.logger.timeEnd(`request-${requestId}`);
-                        return response;
-                    }
-                    // Remove namespace prefix, ensuring we always start with /
-                    requestPath = normalizedPath.substring(finalNamespace.length);
-                    if (!requestPath.startsWith("/")) {
-                        requestPath = `/${requestPath}`;
-                    }
+            if (this.globalConfig.namespace && this.globalConfig.namespace !== "/") {
+                const namespace = this.globalConfig.namespace.startsWith("/")
+                    ? this.globalConfig.namespace
+                    : `/${this.globalConfig.namespace}`;
+                const pathToCheck = path.startsWith("/") ? path : `/${path}`;
+                // Check if path starts with namespace
+                // handle both "/api/users" (starts with /api) and "/api" (exact match)
+                // but NOT "/apiv2" (prefix match but wrong segment)
+                const isMatch = pathToCheck === namespace ||
+                    pathToCheck.startsWith(namespace.endsWith("/") ? namespace : `${namespace}/`);
+                if (!isMatch) {
+                    this.logger.log("route", `[${requestId}] Path doesn't match namespace ${namespace}`);
+                    const error = new RouteNotFoundError(method, path);
+                    const response = {
+                        status: 404,
+                        body: { error: error.message, code: error.code },
+                        headers: {},
+                    };
+                    this.logger.timeEnd(`request-${requestId}`);
+                    return response;
                 }
+                // Remove namespace prefix, ensuring we always start with /
+                const stripped = pathToCheck.slice(namespace.length);
+                requestPath = stripped.startsWith("/") ? stripped : `/${stripped}`;
             }
             // Find matching route
             const matchedRoute = this.findRoute(method, requestPath);
@@ -193,7 +259,7 @@ export class CallableMockInstance {
                 state: this.globalConfig.state || {},
             };
             let result;
-            if (typeof matchedRoute.generator === "function") {
+            if (isGeneratorFunction(matchedRoute.generator)) {
                 result = await matchedRoute.generator(context);
             }
             else {
@@ -218,13 +284,24 @@ export class CallableMockInstance {
                 result = pipelineResult.response;
             }
             catch (error) {
-                this.logger.log("error", `[${requestId}] Plugin pipeline error: ${error.message}`);
+                this.logger.log("error", `[${requestId}] Plugin pipeline error: ${errorMessage(error)}`);
                 throw error;
             }
             // Parse and prepare response
             const response = this.parseResponse(result, matchedRoute.config);
             // Apply global delay if configured
             await this.applyDelay();
+            // Record request in history
+            this.requestHistory.push({
+                method,
+                path: requestPath,
+                params,
+                query: options?.query || {},
+                headers: options?.headers || {},
+                body: options?.body,
+                timestamp: Date.now(),
+                response: { status: response.status, body: response.body },
+            });
             // Log successful response
             this.logger.log("response", `[${requestId}] Sending response ${response.status}`, {
                 status: response.status,
@@ -235,15 +312,13 @@ export class CallableMockInstance {
             return response;
         }
         catch (error) {
-            this.logger.log("error", `[${requestId}] Error processing request: ${error.message}`, error);
+            this.logger.log("error", `[${requestId}] Error processing request: ${errorMessage(error)}`, error);
             // Return error response
             const errorResponse = {
                 status: 500,
                 body: {
-                    error: error.message,
-                    code: error instanceof SchmockError
-                        ? error.code
-                        : "INTERNAL_ERROR",
+                    error: errorMessage(error),
+                    code: error instanceof SchmockError ? error.code : "INTERNAL_ERROR",
                 },
                 headers: {},
             };
@@ -284,10 +359,7 @@ export class CallableMockInstance {
         let headers = {};
         let tupleFormat = false;
         // Handle already-formed response objects (from plugin error recovery)
-        if (result &&
-            typeof result === "object" &&
-            "status" in result &&
-            "body" in result) {
+        if (isResponseObject(result)) {
             return {
                 status: result.status,
                 body: result.body,
@@ -362,28 +434,38 @@ export class CallableMockInstance {
                 }
             }
             catch (error) {
-                this.logger.log("pipeline", `Plugin ${plugin.name} failed: ${error.message}`);
+                this.logger.log("pipeline", `Plugin ${plugin.name} failed: ${errorMessage(error)}`);
                 // Try error handling if plugin has onError hook
                 if (plugin.onError) {
                     try {
-                        const errorResult = await plugin.onError(error, currentContext);
+                        const pluginError = error instanceof Error ? error : new Error(errorMessage(error));
+                        const errorResult = await plugin.onError(pluginError, currentContext);
                         if (errorResult) {
                             this.logger.log("pipeline", `Plugin ${plugin.name} handled error`);
-                            // If error handler returns response, use it and stop pipeline
+                            // Error return → transform the thrown error
+                            if (errorResult instanceof Error) {
+                                throw new PluginError(plugin.name, errorResult);
+                            }
+                            // ResponseResult return → recover, stop pipeline
                             if (typeof errorResult === "object" &&
                                 errorResult !== null &&
                                 "status" in errorResult) {
-                                // Return the error response as the current response, stop pipeline
                                 response = errorResult;
                                 break;
                             }
                         }
+                        // void/falsy return → propagate original error below
                     }
                     catch (hookError) {
-                        this.logger.log("pipeline", `Plugin ${plugin.name} error handler failed: ${hookError.message}`);
+                        // If the hook itself threw (including our PluginError above), re-throw it
+                        if (hookError instanceof PluginError) {
+                            throw hookError;
+                        }
+                        this.logger.log("pipeline", `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`);
                     }
                 }
-                throw new PluginError(plugin.name, error);
+                const cause = error instanceof Error ? error : new Error(errorMessage(error));
+                throw new PluginError(plugin.name, cause);
             }
         }
         return { context: currentContext, response };
@@ -398,15 +480,13 @@ export class CallableMockInstance {
      * @private
      */
     findRoute(method, path) {
-        // First pass: Look for static routes (routes without parameters)
-        for (const route of this.routes) {
-            if (route.method === method &&
-                route.params.length === 0 &&
-                route.pattern.test(path)) {
-                return route;
-            }
+        // O(1) lookup for static routes
+        const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+        const staticMatch = this.staticRoutes.get(`${method} ${normalizedPath}`);
+        if (staticMatch) {
+            return staticMatch;
         }
-        // Second pass: Look for parameterized routes
+        // Fall through to parameterized route scan
         for (const route of this.routes) {
             if (route.method === method &&
                 route.params.length > 0 &&

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import type { CallableMockInstance, GlobalConfig } from "./types.js";
 /**
  * Create a new Schmock mock instance with callable API.
  *
@@ -22,8 +21,8 @@ import type { CallableMockInstance, GlobalConfig } from "./types.js";
  * @param config Optional global configuration
  * @returns A callable mock instance
  */
-export declare function schmock(config?: GlobalConfig): CallableMockInstance;
+export declare function schmock(config?: Schmock.GlobalConfig): Schmock.CallableMockInstance;
 export { HTTP_METHODS, isHttpMethod, ROUTE_NOT_FOUND_CODE, toHttpMethod, } from "./constants.js";
 export { PluginError, ResourceLimitError, ResponseGenerationError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors.js";
-export type { CallableMockInstance, Generator, GeneratorFunction, GlobalConfig, HttpMethod, Plugin, PluginContext, PluginResult, RequestContext, RequestOptions, Response, ResponseBody, ResponseResult, RouteConfig, RouteKey, StaticData, } from "./types.js";
+export type { CallableMockInstance, Generator, GeneratorFunction, GlobalConfig, HttpMethod, Plugin, PluginContext, PluginResult, RequestContext, RequestOptions, RequestRecord, Response, ResponseBody, ResponseResult, RouteConfig, RouteKey, StaticData, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EAEpB,YAAY,EAIb,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,oBAAoB,CAsBnE;AAGD,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,oBAAoB,EACpB,YAAY,GACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,WAAW,EACX,QAAQ,EACR,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CACrB,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,GAC5B,OAAO,CAAC,oBAAoB,CA+B9B;AAGD,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,oBAAoB,EACpB,YAAY,GACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,EACd,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,WAAW,EACX,QAAQ,EACR,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { CallableMockInstance as CallableMockInstanceImpl } from "./builder.js";
+import { CallableMockInstance } from "./builder.js";
 /**
  * Create a new Schmock mock instance with callable API.
  *
@@ -24,18 +24,25 @@ import { CallableMockInstance as CallableMockInstanceImpl } from "./builder.js";
  */
 export function schmock(config) {
     // Always use new callable API
-    const instance = new CallableMockInstanceImpl(config || {});
-    // Create a callable function that wraps the instance
-    const callableInstance = ((route, generator, routeConfig = {}) => {
+    const instance = new CallableMockInstance(config || {});
+    // Callable proxy: a function with attached methods
+    const callableInstance = Object.assign((route, generator, routeConfig = {}) => {
         instance.defineRoute(route, generator, routeConfig);
-        return callableInstance; // Return the callable function for chaining
+        return callableInstance;
+    }, {
+        pipe: (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),
     });
-    // Manually bind all instance methods to the callable function with proper return values
-    callableInstance.pipe = (plugin) => {
-        instance.pipe(plugin);
-        return callableInstance; // Return callable function for chaining
-    };
-    callableInstance.handle = instance.handle.bind(instance);
     return callableInstance;
 }
 // Re-export constants and utilities

package/dist/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAgB7C,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CA4C3D"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAuC3D"}

package/dist/parser.js

@@ -1,16 +1,5 @@
+import { toHttpMethod } from "./constants.js";
 import { RouteParseError } from "./errors.js";
-const HTTP_METHODS = [
-    "GET",
-    "POST",
-    "PUT",
-    "DELETE",
-    "PATCH",
-    "HEAD",
-    "OPTIONS",
-];
-function isHttpMethod(method) {
-    return HTTP_METHODS.includes(method);
-}
 /**
  * Parse 'METHOD /path' route key format
  *
@@ -43,12 +32,8 @@ export function parseRouteKey(routeKey) {
         .replace(/[.*+?^${}()|[\]\\]/g, "\\$&") // Escape special regex chars except :
         .replace(/:([^/]+)/g, "([^/]+)"); // Replace :param with capture group
     const pattern = new RegExp(`^${regexPath}$`);
-    // The regex guarantees method is valid, but we use the type guard for type safety
-    if (!isHttpMethod(method)) {
-        throw new RouteParseError(routeKey, `Invalid HTTP method: ${method}`);
-    }
     return {
-        method,
+        method: toHttpMethod(method),
         path,
         pattern,
         params,