msw-fetch-mock 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 recca0120
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,88 @@
+# msw-fetch-mock
+
+[![CI](https://github.com/recca0120/msw-fetch-mock/actions/workflows/ci.yml/badge.svg)](https://github.com/recca0120/msw-fetch-mock/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/msw-fetch-mock.svg)](https://www.npmjs.com/package/msw-fetch-mock)
+[![license](https://img.shields.io/npm/l/msw-fetch-mock.svg)](https://github.com/recca0120/msw-fetch-mock/blob/main/LICENSE.md)
+
+Undici-style fetch mock API built on [MSW](https://mswjs.io/) (Mock Service Worker).
+
+If you're familiar with Cloudflare Workers' `fetchMock` (from `cloudflare:test`) or Node.js undici's `MockAgent`, you already know this API.
+
+## Install
+
+```bash
+npm install -D msw-fetch-mock msw
+```
+
+`msw` is a peer dependency — you provide your own version.
+
+## Quick Start
+
+```typescript
+import { setupServer } from 'msw/node';
+import { createFetchMock } from 'msw-fetch-mock';
+
+const server = setupServer();
+const fetchMock = createFetchMock(server);
+
+beforeAll(() => fetchMock.activate());
+afterAll(() => fetchMock.deactivate());
+afterEach(() => {
+  fetchMock.clearCallHistory();
+  fetchMock.assertNoPendingInterceptors();
+});
+
+it('mocks a GET request', async () => {
+  fetchMock
+    .get('https://api.example.com')
+    .intercept({ path: '/users', method: 'GET' })
+    .reply(200, { users: [{ id: '1', name: 'Alice' }] });
+
+  const res = await fetch('https://api.example.com/users');
+  const data = await res.json();
+
+  expect(data.users).toHaveLength(1);
+});
+```
+
+## API Overview
+
+### `createFetchMock(server?)`
+
+Creates a `FetchMock` instance. Optionally accepts an existing MSW `SetupServer`; creates one internally if omitted.
+
+### Intercepting & Replying
+
+```typescript
+fetchMock
+  .get(origin)                              // select origin
+  .intercept({ path, method, headers, body, query })  // match criteria
+  .reply(status, body, options)             // define response
+  .times(n) / .persist();                   // repeat control
+```
+
+### Call History
+
+```typescript
+const history = fetchMock.getCallHistory();
+history.calls(); // all calls
+history.lastCall(); // most recent
+history.firstCall(); // earliest
+history.nthCall(2); // 2nd call (1-indexed)
+history.filterCalls({ method: 'POST', path: '/users' }, { operator: 'AND' });
+```
+
+### Assertions
+
+```typescript
+fetchMock.assertNoPendingInterceptors(); // throws if unconsumed interceptors remain
+```
+
+## Documentation
+
+- [API Reference](docs/api.md) — full API details, matching options, reply callbacks
+- [Cloudflare Workers Migration](docs/cloudflare-migration.md) — migrating from `cloudflare:test` fetchMock
+
+## License
+
+[MIT](LICENSE.md)

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createFetchMock, FetchMock } from './mock-server';
+export type { InterceptOptions, MockPool, MockInterceptor, MockReplyChain, ReplyOptions, PendingInterceptor, } from './mock-server';
+export { MockCallHistory, MockCallHistoryLog } from './mock-call-history';
+export type { MockCallHistoryLogData, CallHistoryFilterCriteria } from './mock-call-history';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC3D,YAAY,EACV,gBAAgB,EAChB,QAAQ,EACR,eAAe,EACf,cAAc,EACd,YAAY,EACZ,kBAAkB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC1E,YAAY,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createFetchMock, FetchMock } from './mock-server';
+export { MockCallHistory, MockCallHistoryLog } from './mock-call-history';

package/dist/mock-call-history.d.ts

@@ -0,0 +1,65 @@
+export interface MockCallHistoryLogData {
+    body: string | null;
+    method: string;
+    headers: Record<string, string>;
+    fullUrl: string;
+    origin: string;
+    path: string;
+    searchParams: Record<string, string>;
+    protocol: string;
+    host: string;
+    port: string;
+    hash: string;
+}
+export declare class MockCallHistoryLog {
+    readonly body: string | null;
+    readonly method: string;
+    readonly headers: Record<string, string>;
+    readonly fullUrl: string;
+    readonly origin: string;
+    readonly path: string;
+    readonly searchParams: Record<string, string>;
+    readonly protocol: string;
+    readonly host: string;
+    readonly port: string;
+    readonly hash: string;
+    constructor(data: MockCallHistoryLogData);
+    json(): unknown;
+    toMap(): Map<string, string | null | Record<string, string>>;
+    toString(): string;
+}
+export interface CallHistoryFilterCriteria {
+    method?: string;
+    path?: string;
+    origin?: string;
+    protocol?: string;
+    host?: string;
+    port?: string;
+    hash?: string;
+    fullUrl?: string;
+}
+export declare class MockCallHistory {
+    private logs;
+    get length(): number;
+    record(data: MockCallHistoryLogData): void;
+    called(criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): boolean;
+    calls(): MockCallHistoryLog[];
+    firstCall(criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): MockCallHistoryLog | undefined;
+    lastCall(criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): MockCallHistoryLog | undefined;
+    nthCall(n: number, criteria?: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp): MockCallHistoryLog | undefined;
+    clear(): void;
+    [Symbol.iterator](): Iterator<MockCallHistoryLog>;
+    filterCalls(criteria: ((log: MockCallHistoryLog) => boolean) | CallHistoryFilterCriteria | RegExp, options?: {
+        operator?: 'AND' | 'OR';
+    }): MockCallHistoryLog[];
+    private filterBy;
+    filterCallsByMethod(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByPath(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByOrigin(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByProtocol(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByHost(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByPort(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByHash(filter: string | RegExp): MockCallHistoryLog[];
+    filterCallsByFullUrl(filter: string | RegExp): MockCallHistoryLog[];
+}
+//# sourceMappingURL=mock-call-history.d.ts.map

package/dist/mock-call-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-call-history.d.ts","sourceRoot":"","sources":["../src/mock-call-history.ts"],"names":[],"mappings":"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"}

package/dist/mock-call-history.js

@@ -0,0 +1,140 @@
+export class MockCallHistoryLog {
+    body;
+    method;
+    headers;
+    fullUrl;
+    origin;
+    path;
+    searchParams;
+    protocol;
+    host;
+    port;
+    hash;
+    constructor(data) {
+        this.body = data.body;
+        this.method = data.method;
+        this.headers = data.headers;
+        this.fullUrl = data.fullUrl;
+        this.origin = data.origin;
+        this.path = data.path;
+        this.searchParams = data.searchParams;
+        this.protocol = data.protocol;
+        this.host = data.host;
+        this.port = data.port;
+        this.hash = data.hash;
+    }
+    json() {
+        if (this.body === null)
+            return null;
+        return JSON.parse(this.body);
+    }
+    toMap() {
+        return new Map([
+            ['body', this.body],
+            ['method', this.method],
+            ['headers', this.headers],
+            ['fullUrl', this.fullUrl],
+            ['origin', this.origin],
+            ['path', this.path],
+            ['searchParams', this.searchParams],
+            ['protocol', this.protocol],
+            ['host', this.host],
+            ['port', this.port],
+            ['hash', this.hash],
+        ]);
+    }
+    toString() {
+        return [
+            `method->${this.method}`,
+            `protocol->${this.protocol}`,
+            `host->${this.host}`,
+            `port->${this.port}`,
+            `origin->${this.origin}`,
+            `path->${this.path}`,
+            `hash->${this.hash}`,
+            `fullUrl->${this.fullUrl}`,
+        ].join('|');
+    }
+}
+export class MockCallHistory {
+    logs = [];
+    get length() {
+        return this.logs.length;
+    }
+    record(data) {
+        this.logs.push(data instanceof MockCallHistoryLog ? data : new MockCallHistoryLog(data));
+    }
+    called(criteria) {
+        if (criteria === undefined)
+            return this.logs.length > 0;
+        return this.filterCalls(criteria).length > 0;
+    }
+    calls() {
+        return [...this.logs];
+    }
+    firstCall(criteria) {
+        if (criteria === undefined)
+            return this.logs[0];
+        return this.filterCalls(criteria)[0];
+    }
+    lastCall(criteria) {
+        if (criteria === undefined)
+            return this.logs[this.logs.length - 1];
+        const filtered = this.filterCalls(criteria);
+        return filtered[filtered.length - 1];
+    }
+    nthCall(n, criteria) {
+        if (criteria === undefined)
+            return this.logs[n - 1];
+        return this.filterCalls(criteria)[n - 1];
+    }
+    clear() {
+        this.logs = [];
+    }
+    [Symbol.iterator]() {
+        return this.logs[Symbol.iterator]();
+    }
+    filterCalls(criteria, options) {
+        if (typeof criteria === 'function') {
+            return this.logs.filter(criteria);
+        }
+        if (criteria instanceof RegExp) {
+            return this.logs.filter((log) => criteria.test(log.toString()));
+        }
+        const operator = options?.operator ?? 'OR';
+        const keys = Object.keys(criteria);
+        const predicates = keys
+            .filter((key) => criteria[key] !== undefined)
+            .map((key) => (log) => log[key] === criteria[key]);
+        if (predicates.length === 0)
+            return [...this.logs];
+        return this.logs.filter((log) => operator === 'AND' ? predicates.every((p) => p(log)) : predicates.some((p) => p(log)));
+    }
+    filterBy(field, filter) {
+        return this.logs.filter((log) => typeof filter === 'string' ? log[field] === filter : filter.test(String(log[field])));
+    }
+    filterCallsByMethod(filter) {
+        return this.filterBy('method', filter);
+    }
+    filterCallsByPath(filter) {
+        return this.filterBy('path', filter);
+    }
+    filterCallsByOrigin(filter) {
+        return this.filterBy('origin', filter);
+    }
+    filterCallsByProtocol(filter) {
+        return this.filterBy('protocol', filter);
+    }
+    filterCallsByHost(filter) {
+        return this.filterBy('host', filter);
+    }
+    filterCallsByPort(filter) {
+        return this.filterBy('port', filter);
+    }
+    filterCallsByHash(filter) {
+        return this.filterBy('hash', filter);
+    }
+    filterCallsByFullUrl(filter) {
+        return this.filterBy('fullUrl', filter);
+    }
+}

package/dist/mock-server.d.ts

@@ -0,0 +1,69 @@
+import { MockCallHistory } from './mock-call-history';
+/** Structural type to avoid cross-package nominal type mismatch on MSW's private fields */
+interface SetupServerLike {
+    use(...handlers: Array<unknown>): void;
+    resetHandlers(...handlers: Array<unknown>): void;
+    listen(options?: Record<string, unknown>): void;
+    close(): void;
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type PathMatcher = string | RegExp | ((path: string) => boolean);
+type HeaderValueMatcher = string | RegExp | ((value: string) => boolean);
+type BodyMatcher = string | RegExp | ((body: string) => boolean);
+export interface InterceptOptions {
+    path: PathMatcher;
+    method?: HttpMethod;
+    headers?: Record<string, HeaderValueMatcher>;
+    body?: BodyMatcher;
+    query?: Record<string, string>;
+}
+export interface ReplyOptions {
+    headers?: Record<string, string>;
+}
+type ReplyCallback = (req: {
+    body: string | null;
+}) => unknown | Promise<unknown>;
+export interface MockReplyChain {
+    times(n: number): void;
+    persist(): void;
+    delay(ms: number): void;
+}
+export interface MockInterceptor {
+    reply(status: number, body?: unknown, options?: ReplyOptions): MockReplyChain;
+    reply(status: number, callback: ReplyCallback): MockReplyChain;
+    replyWithError(error: Error): MockReplyChain;
+}
+export interface MockPool {
+    intercept(options: InterceptOptions): MockInterceptor;
+}
+export interface PendingInterceptor {
+    origin: string;
+    path: string;
+    method: string;
+    consumed: boolean;
+    times: number;
+    timesInvoked: number;
+    persist: boolean;
+}
+export declare class FetchMock {
+    private readonly _calls;
+    private server;
+    private readonly ownsServer;
+    private interceptors;
+    private netConnectAllowed;
+    get calls(): MockCallHistory;
+    constructor(externalServer?: SetupServerLike);
+    activate(): void;
+    disableNetConnect(): void;
+    enableNetConnect(matcher?: string | RegExp | ((host: string) => boolean)): void;
+    private isNetConnectAllowed;
+    getCallHistory(): MockCallHistory;
+    clearCallHistory(): void;
+    deactivate(): void;
+    assertNoPendingInterceptors(): void;
+    pendingInterceptors(): PendingInterceptor[];
+    get(origin: string): MockPool;
+}
+export declare function createFetchMock(externalServer?: SetupServerLike): FetchMock;
+export {};
+//# sourceMappingURL=mock-server.d.ts.map

package/dist/mock-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-server.d.ts","sourceRoot":"","sources":["../src/mock-server.ts"],"names":[],"mappings":"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"}

package/dist/mock-server.js

@@ -0,0 +1,269 @@
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+import { MockCallHistory } from './mock-call-history';
+function isPending(p) {
+    if (p.persist)
+        return p.timesInvoked === 0;
+    return p.timesInvoked < p.times;
+}
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function matchesValue(value, matcher) {
+    if (typeof matcher === 'string')
+        return value === matcher;
+    if (matcher instanceof RegExp)
+        return matcher.test(value);
+    return matcher(value);
+}
+function getHttpMethod(method) {
+    const methods = {
+        GET: http.get,
+        POST: http.post,
+        PUT: http.put,
+        DELETE: http.delete,
+        PATCH: http.patch,
+    };
+    return methods[method];
+}
+function matchPath(request, origin, pathMatcher) {
+    if (typeof pathMatcher === 'string')
+        return true; // string paths are matched by MSW URL pattern
+    const url = new URL(request.url);
+    const originPrefix = new URL(origin).pathname.replace(/\/$/, '');
+    const fullPath = url.pathname + url.search;
+    const relativePath = fullPath.startsWith(originPrefix)
+        ? fullPath.slice(originPrefix.length)
+        : fullPath;
+    return matchesValue(relativePath, pathMatcher);
+}
+function matchQuery(request, query) {
+    if (!query)
+        return true;
+    const url = new URL(request.url);
+    for (const [key, value] of Object.entries(query)) {
+        if (url.searchParams.get(key) !== value)
+            return false;
+    }
+    return true;
+}
+function matchHeaders(request, headers) {
+    if (!headers)
+        return true;
+    for (const [key, matcher] of Object.entries(headers)) {
+        const value = request.headers.get(key);
+        if (value === null || !matchesValue(value, matcher))
+            return false;
+    }
+    return true;
+}
+function matchBody(bodyText, bodyMatcher) {
+    if (!bodyMatcher)
+        return true;
+    return matchesValue(bodyText ?? '', bodyMatcher);
+}
+function recordCall(callHistory, request, bodyText) {
+    const url = new URL(request.url);
+    const requestHeaders = {};
+    request.headers.forEach((value, key) => {
+        requestHeaders[key] = value;
+    });
+    const searchParams = {};
+    url.searchParams.forEach((value, key) => {
+        searchParams[key] = value;
+    });
+    callHistory.record({
+        body: bodyText,
+        method: request.method,
+        headers: requestHeaders,
+        fullUrl: url.origin + url.pathname + url.search,
+        origin: url.origin,
+        path: url.pathname,
+        searchParams,
+        protocol: url.protocol,
+        host: url.host,
+        port: url.port,
+        hash: url.hash,
+    });
+}
+function buildResponse(status, responseBody, replyOptions) {
+    const headers = replyOptions?.headers ? new Headers(replyOptions.headers) : undefined;
+    if (responseBody === null || responseBody === undefined) {
+        return new HttpResponse(null, { status, headers });
+    }
+    return HttpResponse.json(responseBody, { status, headers });
+}
+export class FetchMock {
+    _calls = new MockCallHistory();
+    server;
+    ownsServer;
+    interceptors = [];
+    netConnectAllowed = false;
+    get calls() {
+        return this._calls;
+    }
+    constructor(externalServer) {
+        this.server = externalServer ?? null;
+        this.ownsServer = !externalServer;
+    }
+    activate() {
+        if (this.ownsServer) {
+            this.server = setupServer();
+            this.server.listen({
+                onUnhandledRequest: (request, print) => {
+                    if (this.isNetConnectAllowed(request))
+                        return;
+                    print.error();
+                },
+            });
+        }
+    }
+    disableNetConnect() {
+        this.netConnectAllowed = false;
+    }
+    enableNetConnect(matcher) {
+        this.netConnectAllowed = matcher ?? true;
+    }
+    isNetConnectAllowed(request) {
+        if (this.netConnectAllowed === true)
+            return true;
+        if (this.netConnectAllowed === false)
+            return false;
+        const host = new URL(request.url).host;
+        if (typeof this.netConnectAllowed === 'string')
+            return host === this.netConnectAllowed;
+        if (this.netConnectAllowed instanceof RegExp)
+            return this.netConnectAllowed.test(host);
+        return this.netConnectAllowed(host);
+    }
+    getCallHistory() {
+        return this._calls;
+    }
+    clearCallHistory() {
+        this._calls.clear();
+    }
+    deactivate() {
+        this.interceptors = [];
+        this._calls.clear();
+        if (this.ownsServer) {
+            this.server?.close();
+            this.server = null;
+        }
+    }
+    assertNoPendingInterceptors() {
+        const unconsumed = this.interceptors.filter(isPending);
+        this.interceptors = [];
+        this._calls.clear();
+        if (this.ownsServer) {
+            this.server?.resetHandlers();
+        }
+        if (unconsumed.length > 0) {
+            const descriptions = unconsumed.map((p) => `  ${p.method} ${p.origin}${p.path}`);
+            throw new Error(`Pending interceptor(s) not consumed:\n${descriptions.join('\n')}`);
+        }
+    }
+    pendingInterceptors() {
+        return this.interceptors.filter(isPending).map((p) => ({ ...p }));
+    }
+    get(origin) {
+        return {
+            intercept: (options) => {
+                const method = options.method ?? 'GET';
+                const pathStr = typeof options.path === 'string'
+                    ? options.path
+                    : typeof options.path === 'function'
+                        ? '<function>'
+                        : options.path.toString();
+                const pending = {
+                    origin,
+                    path: pathStr,
+                    method,
+                    consumed: false,
+                    times: 1,
+                    timesInvoked: 0,
+                    persist: false,
+                };
+                this.interceptors.push(pending);
+                const urlPattern = typeof options.path === 'string'
+                    ? `${origin}${options.path}`
+                    : new RegExp(`^${escapeRegExp(origin)}`);
+                const matchAndConsume = async (request) => {
+                    if (!pending.persist && pending.timesInvoked >= pending.times)
+                        return;
+                    if (!matchPath(request, origin, options.path))
+                        return;
+                    if (!matchQuery(request, options.query))
+                        return;
+                    if (!matchHeaders(request, options.headers))
+                        return;
+                    const bodyText = (await request.text()) || null;
+                    if (!matchBody(bodyText, options.body))
+                        return;
+                    pending.timesInvoked++;
+                    if (!pending.persist && pending.timesInvoked >= pending.times) {
+                        pending.consumed = true;
+                    }
+                    recordCall(this._calls, request, bodyText);
+                    return bodyText;
+                };
+                const registerHandler = (handlerFn) => {
+                    const handler = getHttpMethod(method)(urlPattern, async ({ request }) => handlerFn(request));
+                    if (!this.server) {
+                        throw new Error('FetchMock server is not active. Call activate() before registering interceptors.');
+                    }
+                    this.server.use(handler);
+                };
+                const buildChain = (delayRef) => ({
+                    times(n) {
+                        pending.times = n;
+                        pending.consumed = false;
+                    },
+                    persist() {
+                        pending.persist = true;
+                        pending.consumed = false;
+                    },
+                    delay(ms) {
+                        delayRef.ms = ms;
+                    },
+                });
+                return {
+                    reply: (status, bodyOrCallback, replyOptions) => {
+                        const delayRef = { ms: 0 };
+                        registerHandler(async (request) => {
+                            const bodyText = await matchAndConsume(request);
+                            if (bodyText === undefined)
+                                return;
+                            if (delayRef.ms > 0) {
+                                await new Promise((resolve) => setTimeout(resolve, delayRef.ms));
+                            }
+                            let responseBody;
+                            if (typeof bodyOrCallback === 'function') {
+                                responseBody = await bodyOrCallback({
+                                    body: bodyText || null,
+                                });
+                            }
+                            else {
+                                responseBody = bodyOrCallback;
+                            }
+                            return buildResponse(status, responseBody, replyOptions);
+                        });
+                        return buildChain(delayRef);
+                    },
+                    replyWithError: () => {
+                        const delayRef = { ms: 0 };
+                        registerHandler(async (request) => {
+                            const bodyText = await matchAndConsume(request);
+                            if (bodyText === undefined)
+                                return;
+                            return HttpResponse.error();
+                        });
+                        return buildChain(delayRef);
+                    },
+                };
+            },
+        };
+    }
+}
+export function createFetchMock(externalServer) {
+    return new FetchMock(externalServer);
+}

package/docs/api.md

@@ -0,0 +1,472 @@
+# API Reference
+
+## `new FetchMock(server?)`
+
+Creates a `FetchMock` instance.
+
+```typescript
+import { FetchMock } from 'msw-fetch-mock';
+
+// Standalone (creates internal MSW server)
+const fetchMock = new FetchMock();
+
+// With external MSW server
+import { setupServer } from 'msw/node';
+const server = setupServer();
+const fetchMock = new FetchMock(server);
+```
+
+| Parameter | Type          | Required | Description                                             |
+| --------- | ------------- | -------- | ------------------------------------------------------- |
+| `server`  | `SetupServer` | No       | Existing MSW server. Creates one internally if omitted. |
+
+> `createFetchMock(server?)` is also available as a backward-compatible factory function.
+
+---
+
+## `FetchMock`
+
+### Lifecycle
+
+```typescript
+fetchMock.activate(); // start intercepting (calls server.listen())
+fetchMock.deactivate(); // stop intercepting (calls server.close())
+```
+
+> If you pass an external server that you manage yourself, `activate()` / `deactivate()` are no-ops.
+
+### `fetchMock.calls`
+
+Returns the `MockCallHistory` instance for inspecting and managing recorded requests.
+
+```typescript
+// Check call count
+expect(fetchMock.calls.length).toBe(3);
+
+// Inspect last call
+const last = fetchMock.calls.lastCall();
+
+// Clear history
+fetchMock.calls.clear();
+```
+
+### `fetchMock.get(origin)`
+
+Returns a `MockPool` scoped to the given origin.
+
+```typescript
+const pool = fetchMock.get('https://api.example.com');
+```
+
+### `fetchMock.disableNetConnect()`
+
+Prevents any real network requests. Unmatched requests will throw.
+
+### `fetchMock.enableNetConnect(matcher?)`
+
+Allows real network requests to pass through. Without arguments, all requests are allowed. With a matcher, only matching hosts pass through.
+
+```typescript
+// Allow all network requests
+fetchMock.enableNetConnect();
+
+// Allow specific host (exact match)
+fetchMock.enableNetConnect('api.example.com');
+
+// Allow hosts matching a RegExp
+fetchMock.enableNetConnect(/\.example\.com$/);
+
+// Allow hosts matching a function
+fetchMock.enableNetConnect((host) => host.endsWith('.test'));
+```
+
+| Parameter | Type                                            | Required | Description                          |
+| --------- | ----------------------------------------------- | -------- | ------------------------------------ |
+| `matcher` | `string \| RegExp \| (host: string) => boolean` | No       | Host matcher. Allows all if omitted. |
+
+### `fetchMock.getCallHistory()`
+
+Returns the `MockCallHistory` instance. Cloudflare-compatible alias for `fetchMock.calls`.
+
+### `fetchMock.clearCallHistory()`
+
+Clears all recorded calls. Cloudflare-compatible alias for `fetchMock.calls.clear()`.
+
+### `fetchMock.assertNoPendingInterceptors()`
+
+Throws an error if any registered interceptor has not been consumed. Also **automatically clears** call history and resets handlers. Use in `afterEach` to catch missing requests.
+
+```typescript
+afterEach(() => fetchMock.assertNoPendingInterceptors());
+```
+
+> Call history is cleared automatically — no need for a separate `calls.clear()` call.
+
+### `fetchMock.pendingInterceptors()`
+
+Returns an array of unconsumed interceptors with metadata:
+
+```typescript
+interface PendingInterceptor {
+  origin: string;
+  path: string;
+  method: string;
+  consumed: boolean;
+  times: number;
+  timesInvoked: number;
+  persist: boolean;
+}
+```
+
+---
+
+## `MockPool`
+
+### `pool.intercept(options)`
+
+Registers an interceptor for matching requests.
+
+```typescript
+pool.intercept({
+  path: '/users',
+  method: 'GET',
+});
+```
+
+Returns: `MockInterceptor`
+
+#### `InterceptOptions`
+
+| Property  | Type                                                             | Required | Description                            |
+| --------- | ---------------------------------------------------------------- | -------- | -------------------------------------- |
+| `path`    | `string \| RegExp \| (path: string) => boolean`                  | Yes      | URL pathname to match                  |
+| `method`  | `'GET' \| 'POST' \| 'PUT' \| 'DELETE' \| 'PATCH'`                | No       | HTTP method (default: `'GET'`)         |
+| `headers` | `Record<string, string \| RegExp \| (value: string) => boolean>` | No       | Header matchers                        |
+| `body`    | `string \| RegExp \| (body: string) => boolean`                  | No       | Request body matcher                   |
+| `query`   | `Record<string, string>`                                         | No       | Query parameter matchers (exact match) |
+
+#### Path Matching
+
+```typescript
+// Exact string
+.intercept({ path: '/users' })
+
+// RegExp
+.intercept({ path: /^\/users\/\d+$/ })
+
+// Function
+.intercept({ path: (p) => p.startsWith('/users') })
+```
+
+#### Header Matching
+
+```typescript
+.intercept({
+  path: '/api',
+  method: 'POST',
+  headers: {
+    'content-type': 'application/json',         // exact match
+    authorization: /^Bearer /,                   // regex
+    'x-custom': (v) => v.includes('special'),   // function
+  },
+})
+```
+
+#### Body Matching
+
+```typescript
+.intercept({
+  path: '/api',
+  method: 'POST',
+  body: '{"key":"value"}',            // exact match
+  // body: /keyword/,                 // regex
+  // body: (b) => b.includes('key'),  // function
+})
+```
+
+#### Query Parameters
+
+```typescript
+.intercept({
+  path: '/search',
+  method: 'GET',
+  query: { q: 'test', page: '1' },
+})
+```
+
+---
+
+## `MockInterceptor`
+
+### `interceptor.reply(status, body?, options?)`
+
+Defines the mock response.
+
+```typescript
+// Static body
+.reply(200, { users: [] })
+
+// With response headers
+.reply(200, { users: [] }, { headers: { 'x-request-id': '123' } })
+
+// Callback (receives request info)
+.reply(200, (req) => {
+  const input = JSON.parse(req.body!);
+  return { echo: input };
+})
+```
+
+Returns: `MockReplyChain`
+
+| Parameter | Type                                   | Description               |
+| --------- | -------------------------------------- | ------------------------- |
+| `status`  | `number`                               | HTTP status code          |
+| `body`    | `unknown \| (req) => unknown`          | Response body or callback |
+| `options` | `{ headers?: Record<string, string> }` | Response headers          |
+
+### `interceptor.replyWithError(error)`
+
+Replies with a network error (simulates a connection failure).
+
+```typescript
+.replyWithError(new Error('connection refused'))
+```
+
+Returns: `MockReplyChain`
+
+| Parameter | Type    | Description                              |
+| --------- | ------- | ---------------------------------------- |
+| `error`   | `Error` | The error instance (used for semantics). |
+
+---
+
+## `MockReplyChain`
+
+### `chain.times(n)`
+
+Interceptor will match exactly `n` times, then be consumed.
+
+```typescript
+.reply(200, { ok: true }).times(3)
+```
+
+### `chain.persist()`
+
+Interceptor will match indefinitely (never consumed).
+
+```typescript
+.reply(200, { ok: true }).persist()
+```
+
+### `chain.delay(ms)`
+
+Adds a delay before the response is sent.
+
+```typescript
+.reply(200, { ok: true }).delay(500)
+```
+
+---
+
+## `MockCallHistory`
+
+Tracks all requests that pass through the mock server.
+
+### `history.length`
+
+Returns the number of recorded calls.
+
+```typescript
+expect(fetchMock.calls.length).toBe(3);
+```
+
+### `history.called(criteria?)`
+
+Returns `true` if any calls match the given criteria, or if any calls exist when no criteria is provided.
+
+```typescript
+// Any calls recorded?
+expect(fetchMock.calls.called()).toBe(true);
+
+// Calls matching a filter?
+expect(fetchMock.calls.called({ method: 'POST' })).toBe(true);
+expect(fetchMock.calls.called(/\/users/)).toBe(true);
+expect(fetchMock.calls.called((log) => log.path === '/users')).toBe(true);
+```
+
+### `history.calls()`
+
+Returns a copy of all recorded `MockCallHistoryLog` entries.
+
+### `history.firstCall(criteria?)`
+
+Returns the first recorded call, or `undefined`. Optionally filters by criteria.
+
+```typescript
+const first = fetchMock.calls.firstCall();
+const firstPost = fetchMock.calls.firstCall({ method: 'POST' });
+```
+
+### `history.lastCall(criteria?)`
+
+Returns the most recent recorded call, or `undefined`. Optionally filters by criteria.
+
+```typescript
+const last = fetchMock.calls.lastCall();
+const lastPost = fetchMock.calls.lastCall({ method: 'POST' });
+```
+
+### `history.nthCall(n, criteria?)`
+
+Returns the nth call (1-indexed), or `undefined`. Optionally filters by criteria.
+
+```typescript
+const second = fetchMock.calls.nthCall(2);
+const secondPost = fetchMock.calls.nthCall(2, { method: 'POST' });
+```
+
+### `history.clear()`
+
+Removes all recorded calls.
+
+### `history.filterCalls(criteria, options?)`
+
+Flexible filtering with three overloads:
+
+```typescript
+// Function predicate
+history.filterCalls((log) => log.body?.includes('test'));
+
+// RegExp (tested against log.toString())
+history.filterCalls(/POST.*\/users/);
+
+// Structured criteria
+history.filterCalls(
+  { method: 'POST', path: '/users' },
+  { operator: 'AND' } // default: 'OR'
+);
+```
+
+#### `CallHistoryFilterCriteria`
+
+| Property   | Type     | Description  |
+| ---------- | -------- | ------------ |
+| `method`   | `string` | HTTP method  |
+| `path`     | `string` | URL pathname |
+| `origin`   | `string` | URL origin   |
+| `protocol` | `string` | URL protocol |
+| `host`     | `string` | URL host     |
+| `port`     | `string` | URL port     |
+| `hash`     | `string` | URL hash     |
+| `fullUrl`  | `string` | Complete URL |
+
+### `history.filterCallsByMethod(filter)`
+
+```typescript
+history.filterCallsByMethod('POST');
+history.filterCallsByMethod(/^P/); // POST, PUT, PATCH
+```
+
+### `history.filterCallsByPath(filter)`
+
+```typescript
+history.filterCallsByPath('/users');
+history.filterCallsByPath(/\/users\/\d+/);
+```
+
+### `history.filterCallsByOrigin(filter)`
+
+```typescript
+history.filterCallsByOrigin('https://api.example.com');
+history.filterCallsByOrigin(/example\.com/);
+```
+
+### `history.filterCallsByProtocol(filter)`
+
+```typescript
+history.filterCallsByProtocol('https:');
+```
+
+### `history.filterCallsByHost(filter)`
+
+```typescript
+history.filterCallsByHost('api.example.com');
+history.filterCallsByHost(/example\.com/);
+```
+
+### `history.filterCallsByPort(filter)`
+
+```typescript
+history.filterCallsByPort('8787');
+```
+
+### `history.filterCallsByHash(filter)`
+
+```typescript
+history.filterCallsByHash('#section');
+```
+
+### `history.filterCallsByFullUrl(filter)`
+
+```typescript
+history.filterCallsByFullUrl('https://api.example.com/users');
+history.filterCallsByFullUrl(/\/users\?page=1/);
+```
+
+### Iteration
+
+`MockCallHistory` implements `Symbol.iterator`:
+
+```typescript
+for (const call of history) {
+  console.log(call.method, call.path);
+}
+```
+
+---
+
+## `MockCallHistoryLog`
+
+Each recorded call is an instance of `MockCallHistoryLog` with the following properties:
+
+| Property       | Type                     | Description                        |
+| -------------- | ------------------------ | ---------------------------------- |
+| `method`       | `string`                 | HTTP method                        |
+| `fullUrl`      | `string`                 | Complete URL                       |
+| `origin`       | `string`                 | URL origin (`https://example.com`) |
+| `path`         | `string`                 | URL pathname (`/users`)            |
+| `searchParams` | `Record<string, string>` | Query parameters                   |
+| `headers`      | `Record<string, string>` | Request headers                    |
+| `body`         | `string \| null`         | Request body                       |
+| `protocol`     | `string`                 | URL protocol (`https:`)            |
+| `host`         | `string`                 | URL host                           |
+| `port`         | `string`                 | URL port                           |
+| `hash`         | `string`                 | URL hash                           |
+
+### `log.json()`
+
+Parses the request body as JSON. Returns `null` if body is `null`.
+
+```typescript
+const call = fetchMock.calls.lastCall()!;
+const data = call.json() as { name: string };
+expect(data.name).toBe('Alice');
+```
+
+### `log.toMap()`
+
+Returns a `Map` of all log properties.
+
+```typescript
+const map = call.toMap();
+expect(map.get('method')).toBe('POST');
+```
+
+### `log.toString()`
+
+Returns a pipe-delimited string representation for debugging and RegExp matching.
+
+```typescript
+call.toString();
+// "method->POST|protocol->https:|host->api.example.com|port->|origin->https://api.example.com|path->/users|hash->|fullUrl->https://api.example.com/users"
+```

package/docs/cloudflare-migration.md

@@ -0,0 +1,78 @@
+# Cloudflare Workers Migration Guide
+
+If you're migrating tests from Cloudflare Workers' `cloudflare:test` to a standard Node.js test environment, `msw-fetch-mock` provides the same `fetchMock` API you already know.
+
+## API Comparison
+
+| cloudflare:test                                    | msw-fetch-mock                                              |
+| -------------------------------------------------- | ----------------------------------------------------------- |
+| `import { fetchMock } from 'cloudflare:test'`      | `const fetchMock = new FetchMock(server)`                   |
+| `fetchMock.activate()`                             | `fetchMock.activate()`                                      |
+| `fetchMock.disableNetConnect()`                    | `fetchMock.disableNetConnect()`                             |
+| `fetchMock.enableNetConnect(matcher?)`             | `fetchMock.enableNetConnect(matcher?)`                      |
+| `fetchMock.deactivate()`                           | `fetchMock.deactivate()`                                    |
+| `fetchMock.get(origin).intercept(opts).reply(...)` | `fetchMock.get(origin).intercept(opts).reply(...)`          |
+| `.replyWithError(error)`                           | `.replyWithError(error)`                                    |
+| `.reply(...).delay(ms)`                            | `.reply(...).delay(ms)`                                     |
+| `fetchMock.getCallHistory()`                       | `fetchMock.getCallHistory()` or `fetchMock.calls`           |
+| `fetchMock.clearCallHistory()`                     | `fetchMock.clearCallHistory()` or `fetchMock.calls.clear()` |
+| `fetchMock.assertNoPendingInterceptors()`          | `fetchMock.assertNoPendingInterceptors()`                   |
+
+## Before (cloudflare:test)
+
+```typescript
+import { fetchMock } from 'cloudflare:test';
+
+beforeEach(() => {
+  fetchMock.activate();
+  fetchMock.disableNetConnect();
+});
+
+afterEach(() => fetchMock.assertNoPendingInterceptors());
+
+it('calls API', async () => {
+  fetchMock
+    .get('https://api.example.com')
+    .intercept({ path: '/data', method: 'GET' })
+    .reply(200, { result: 'ok' });
+
+  const res = await fetch('https://api.example.com/data');
+  expect(await res.json()).toEqual({ result: 'ok' });
+});
+```
+
+## After (msw-fetch-mock)
+
+```typescript
+import { setupServer } from 'msw/node';
+import { FetchMock } from 'msw-fetch-mock';
+
+const server = setupServer();
+const fetchMock = new FetchMock(server);
+
+beforeAll(() => fetchMock.activate());
+afterAll(() => fetchMock.deactivate());
+afterEach(() => fetchMock.assertNoPendingInterceptors());
+
+it('calls API', async () => {
+  fetchMock
+    .get('https://api.example.com')
+    .intercept({ path: '/data', method: 'GET' })
+    .reply(200, { result: 'ok' });
+
+  const res = await fetch('https://api.example.com/data');
+  expect(await res.json()).toEqual({ result: 'ok' });
+});
+```
+
+## Key Differences
+
+| Aspect               | cloudflare:test                      | msw-fetch-mock                                    |
+| -------------------- | ------------------------------------ | ------------------------------------------------- |
+| Server lifecycle     | Implicit (managed by test framework) | Explicit (`activate()` / `deactivate()`)          |
+| Call history access  | `fetchMock.getCallHistory()`         | `fetchMock.getCallHistory()` or `fetchMock.calls` |
+| Call history cleanup | Automatic per test                   | Automatic via `assertNoPendingInterceptors()`     |
+| Network connect      | Must call `disableNetConnect()`      | MSW blocks unhandled requests by default          |
+| Runtime              | Cloudflare Workers (workerd)         | Node.js                                           |
+
+> **Note:** `getCallHistory()` and `clearCallHistory()` are provided as Cloudflare-compatible aliases. You can use either the Cloudflare-style methods or the `fetchMock.calls` getter — they are equivalent.

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "msw-fetch-mock",
+  "version": "0.1.0",
+  "description": "Undici-style fetch mock API built on MSW (Mock Service Worker)",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "msw",
+    "fetch",
+    "mock",
+    "testing",
+    "undici"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/recca0120/msw-fetch-mock.git"
+  },
+  "packageManager": "pnpm@10.12.4",
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "docs",
+    "LICENSE.md",
+    "README.md"
+  ],
+  "scripts": {
+    "prepare": "lefthook install",
+    "build": "tsc",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepublishOnly": "tsc"
+  },
+  "peerDependencies": {
+    "msw": "^2.12.7"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "eslint": "^9.39.2",
+    "lefthook": "^2.0.15",
+    "msw": "^2.12.7",
+    "prettier": "^3.8.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.1",
+    "vitest": "^4.0.17"
+  }
+}