@stratal/testing 0.0.0-canary-6cccfef → 0.0.0-canary-7f2772b

package/dist/_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.mjs

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate };

package/dist/_virtual/_@oxc-project_runtime@0.115.0/helpers/decorateMetadata.mjs

@@ -0,0 +1,6 @@
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+export { __decorateMetadata };

package/dist/_virtual/_@oxc-project_runtime@0.115.0/helpers/decorateParam.mjs

@@ -0,0 +1,8 @@
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+export { __decorateParam };

package/dist/auth/acting-as.d.mts

@@ -0,0 +1,25 @@
+import { AuthService } from "@stratal/framework/auth";
+
+//#region src/auth/acting-as.d.ts
+/**
+ * ActingAs
+ *
+ * Creates authentication sessions for testing.
+ * Uses Better Auth's internalAdapter to create real database sessions.
+ *
+ * @example
+ * ```typescript
+ * const actingAs = new ActingAs(authService)
+ * const headers = await actingAs.createSessionForUser({ id: 'user-123' })
+ * ```
+ */
+declare class ActingAs {
+  private readonly authService;
+  constructor(authService: AuthService);
+  createSessionForUser(user: {
+    id: string;
+  }): Promise<Headers>;
+}
+//#endregion
+export { ActingAs };
+//# sourceMappingURL=acting-as.d.mts.map

package/dist/auth/acting-as.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acting-as.d.mts","names":[],"sources":["../../src/auth/acting-as.ts"],"mappings":";;;;;AAoCA;;;;;;;;;;cAAa,QAAA;EAAA,iBACkB,WAAA;cAAA,WAAA,EAAa,WAAA;EAEpC,oBAAA,CAAqB,IAAA;IAAQ,EAAA;EAAA,IAAe,OAAA,CAAQ,OAAA;AAAA"}

package/dist/auth/acting-as.mjs

@@ -0,0 +1,69 @@
+import { setSessionCookie } from "better-auth/cookies";
+import { convertSetCookieToCookie } from "better-auth/test";
+//#region src/auth/acting-as.ts
+async function makeSignature(value, secret) {
+	const algorithm = {
+		name: "HMAC",
+		hash: "SHA-256"
+	};
+	const secretBuf = new TextEncoder().encode(secret);
+	const key = await crypto.subtle.importKey("raw", secretBuf, algorithm, false, ["sign"]);
+	const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
+	return btoa(String.fromCharCode(...new Uint8Array(signature)));
+}
+function buildCookieString(name, value, options = {}) {
+	let str = `${name}=${encodeURIComponent(value)}`;
+	if (options.path) str += `; Path=${options.path}`;
+	if (options.httpOnly) str += "; HttpOnly";
+	if (options.secure) str += "; Secure";
+	if (options.sameSite) str += `; SameSite=${options.sameSite}`;
+	if (options.maxAge !== void 0) str += `; Max-Age=${Math.floor(options.maxAge)}`;
+	return str;
+}
+/**
+* ActingAs
+*
+* Creates authentication sessions for testing.
+* Uses Better Auth's internalAdapter to create real database sessions.
+*
+* @example
+* ```typescript
+* const actingAs = new ActingAs(authService)
+* const headers = await actingAs.createSessionForUser({ id: 'user-123' })
+* ```
+*/
+var ActingAs = class {
+	constructor(authService) {
+		this.authService = authService;
+	}
+	async createSessionForUser(user) {
+		const ctx = await this.authService.auth.$context;
+		const secret = ctx.secret;
+		const session = await ctx.internalAdapter.createSession(user.id, void 0, {
+			ipAddress: "127.0.0.1",
+			userAgent: "test-client"
+		});
+		const dbUser = await ctx.internalAdapter.findUserById(user.id);
+		if (!dbUser) throw new Error(`User not found: ${user.id}`);
+		const responseHeaders = new Headers();
+		await setSessionCookie({
+			context: ctx,
+			getSignedCookie: () => null,
+			setSignedCookie: async (name, value, _secret, options = {}) => {
+				const signedValue = `${value}.${await makeSignature(value, secret)}`;
+				responseHeaders.append("Set-Cookie", buildCookieString(name, signedValue, options));
+			},
+			setCookie: (name, value, options = {}) => {
+				responseHeaders.append("Set-Cookie", buildCookieString(name, value, options));
+			}
+		}, {
+			session,
+			user: dbUser
+		}, false);
+		return convertSetCookieToCookie(responseHeaders);
+	}
+};
+//#endregion
+export { ActingAs };
+
+//# sourceMappingURL=acting-as.mjs.map

package/dist/auth/acting-as.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"acting-as.mjs","names":[],"sources":["../../src/auth/acting-as.ts"],"sourcesContent":["import type { AuthService } from '@stratal/framework/auth'\nimport { type GenericEndpointContext } from 'better-auth'\nimport { setSessionCookie } from 'better-auth/cookies'\nimport { convertSetCookieToCookie } from 'better-auth/test'\n\nasync function makeSignature(value: string, secret: string): Promise<string> {\n  const algorithm = { name: 'HMAC', hash: 'SHA-256' }\n  const secretBuf = new TextEncoder().encode(secret)\n  const key = await crypto.subtle.importKey('raw', secretBuf, algorithm, false, ['sign'])\n  const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value))\n  return btoa(String.fromCharCode(...new Uint8Array(signature)))\n}\n\nfunction buildCookieString(name: string, value: string, options: Record<string, unknown> = {}): string {\n  const encodedValue = encodeURIComponent(value)\n  let str = `${name}=${encodedValue}`\n  if (options.path) str += `; Path=${options.path as string}`\n  if (options.httpOnly) str += '; HttpOnly'\n  if (options.secure) str += '; Secure'\n  if (options.sameSite) str += `; SameSite=${options.sameSite as string}`\n  if (options.maxAge !== undefined) str += `; Max-Age=${Math.floor(options.maxAge as number)}`\n  return str\n}\n\n/**\n * ActingAs\n *\n * Creates authentication sessions for testing.\n * Uses Better Auth's internalAdapter to create real database sessions.\n *\n * @example\n * ```typescript\n * const actingAs = new ActingAs(authService)\n * const headers = await actingAs.createSessionForUser({ id: 'user-123' })\n * ```\n */\nexport class ActingAs {\n  constructor(private readonly authService: AuthService) { }\n\n  async createSessionForUser(user: { id: string }): Promise<Headers> {\n    const auth = this.authService.auth\n    const ctx = await auth.$context\n\n    const secret = ctx.secret\n\n    const session = await ctx.internalAdapter.createSession(\n      user.id,\n      undefined,\n      { ipAddress: '127.0.0.1', userAgent: 'test-client' }\n    )\n\n    const dbUser = await ctx.internalAdapter.findUserById(user.id)\n    if (!dbUser) {\n      throw new Error(`User not found: ${user.id}`)\n    }\n\n    const responseHeaders = new Headers()\n    const mockCtx = {\n      context: ctx,\n      getSignedCookie: () => null,\n      setSignedCookie: async (name: string, value: string, _secret: string, options: Record<string, unknown> = {}) => {\n        const signature = await makeSignature(value, secret)\n        const signedValue = `${value}.${signature}`\n        responseHeaders.append('Set-Cookie', buildCookieString(name, signedValue, options))\n      },\n      setCookie: (name: string, value: string, options: Record<string, unknown> = {}) => {\n        responseHeaders.append('Set-Cookie', buildCookieString(name, value, options))\n      },\n    }\n\n    await setSessionCookie(mockCtx as unknown as GenericEndpointContext, { session, user: dbUser }, false)\n    return convertSetCookieToCookie(responseHeaders)\n  }\n}\n"],"mappings":";;;AAKA,eAAe,cAAc,OAAe,QAAiC;CAC3E,MAAM,YAAY;EAAE,MAAM;EAAQ,MAAM;EAAW;CACnD,MAAM,YAAY,IAAI,aAAa,CAAC,OAAO,OAAO;CAClD,MAAM,MAAM,MAAM,OAAO,OAAO,UAAU,OAAO,WAAW,WAAW,OAAO,CAAC,OAAO,CAAC;CACvF,MAAM,YAAY,MAAM,OAAO,OAAO,KAAK,UAAU,MAAM,KAAK,IAAI,aAAa,CAAC,OAAO,MAAM,CAAC;AAChG,QAAO,KAAK,OAAO,aAAa,GAAG,IAAI,WAAW,UAAU,CAAC,CAAC;;AAGhE,SAAS,kBAAkB,MAAc,OAAe,UAAmC,EAAE,EAAU;CAErG,IAAI,MAAM,GAAG,KAAK,GADG,mBAAmB,MAAM;AAE9C,KAAI,QAAQ,KAAM,QAAO,UAAU,QAAQ;AAC3C,KAAI,QAAQ,SAAU,QAAO;AAC7B,KAAI,QAAQ,OAAQ,QAAO;AAC3B,KAAI,QAAQ,SAAU,QAAO,cAAc,QAAQ;AACnD,KAAI,QAAQ,WAAW,KAAA,EAAW,QAAO,aAAa,KAAK,MAAM,QAAQ,OAAiB;AAC1F,QAAO;;;;;;;;;;;;;;AAeT,IAAa,WAAb,MAAsB;CACpB,YAAY,aAA2C;AAA1B,OAAA,cAAA;;CAE7B,MAAM,qBAAqB,MAAwC;EAEjE,MAAM,MAAM,MADC,KAAK,YAAY,KACP;EAEvB,MAAM,SAAS,IAAI;EAEnB,MAAM,UAAU,MAAM,IAAI,gBAAgB,cACxC,KAAK,IACL,KAAA,GACA;GAAE,WAAW;GAAa,WAAW;GAAe,CACrD;EAED,MAAM,SAAS,MAAM,IAAI,gBAAgB,aAAa,KAAK,GAAG;AAC9D,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,mBAAmB,KAAK,KAAK;EAG/C,MAAM,kBAAkB,IAAI,SAAS;AAcrC,QAAM,iBAbU;GACd,SAAS;GACT,uBAAuB;GACvB,iBAAiB,OAAO,MAAc,OAAe,SAAiB,UAAmC,EAAE,KAAK;IAE9G,MAAM,cAAc,GAAG,MAAM,GADX,MAAM,cAAc,OAAO,OAAO;AAEpD,oBAAgB,OAAO,cAAc,kBAAkB,MAAM,aAAa,QAAQ,CAAC;;GAErF,YAAY,MAAc,OAAe,UAAmC,EAAE,KAAK;AACjF,oBAAgB,OAAO,cAAc,kBAAkB,MAAM,OAAO,QAAQ,CAAC;;GAEhF,EAEoE;GAAE;GAAS,MAAM;GAAQ,EAAE,MAAM;AACtG,SAAO,yBAAyB,gBAAgB"}

package/dist/auth/index.d.mts

@@ -0,0 +1 @@
+import { ActingAs } from "./acting-as.mjs";

package/dist/auth/index.mjs

@@ -0,0 +1,2 @@
+import "./acting-as.mjs";
+export {};

package/dist/core/env/index.d.mts

@@ -0,0 +1 @@
+import { getTestEnv } from "./test-env.mjs";

package/dist/core/env/index.mjs

@@ -0,0 +1,2 @@
+import "./test-env.mjs";
+export {};

package/dist/core/env/test-env.d.mts

@@ -0,0 +1,13 @@
+import { StratalEnv } from "stratal";
+
+//#region src/core/env/test-env.d.ts
+/**
+ * Get test environment with optional overrides
+ *
+ * @param overrides - Optional partial env to merge with cloudflare:test env
+ * @returns Complete Env object for testing
+ */
+declare function getTestEnv(overrides?: Partial<StratalEnv>): StratalEnv;
+//#endregion
+export { getTestEnv };
+//# sourceMappingURL=test-env.d.mts.map

package/dist/core/env/test-env.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-env.d.mts","names":[],"sources":["../../../src/core/env/test-env.ts"],"mappings":";;;;;AASA;;;;iBAAgB,UAAA,CAAW,SAAA,GAAY,OAAA,CAAQ,UAAA,IAAc,UAAA"}

package/dist/core/env/test-env.mjs

@@ -0,0 +1,18 @@
+import { env } from "cloudflare:workers";
+//#region src/core/env/test-env.ts
+/**
+* Get test environment with optional overrides
+*
+* @param overrides - Optional partial env to merge with cloudflare:test env
+* @returns Complete Env object for testing
+*/
+function getTestEnv(overrides) {
+	return {
+		...env,
+		...overrides
+	};
+}
+//#endregion
+export { getTestEnv };
+
+//# sourceMappingURL=test-env.mjs.map

package/dist/core/env/test-env.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-env.mjs","names":["cloudflareEnv"],"sources":["../../../src/core/env/test-env.ts"],"sourcesContent":["import { type StratalEnv } from 'stratal'\nimport { env as cloudflareEnv } from 'cloudflare:workers'\n\n/**\n * Get test environment with optional overrides\n *\n * @param overrides - Optional partial env to merge with cloudflare:test env\n * @returns Complete Env object for testing\n */\nexport function getTestEnv(overrides?: Partial<StratalEnv>): StratalEnv {\n  return {\n    ...cloudflareEnv,\n    ...overrides,\n  } as StratalEnv\n}\n"],"mappings":";;;;;;;;AASA,SAAgB,WAAW,WAA6C;AACtE,QAAO;EACL,GAAGA;EACH,GAAG;EACJ"}

package/dist/core/http/fetch-mock.types.d.mts

@@ -0,0 +1,51 @@
+//#region src/core/http/fetch-mock.types.d.ts
+/**
+ * Options for mocking JSON responses
+ */
+interface MockJsonOptions {
+  /**
+   * HTTP status code for the response
+   * @default 200
+   */
+  status?: number;
+  /**
+   * Custom headers to include in the response
+   */
+  headers?: Record<string, string>;
+  /**
+   * Delay in milliseconds before responding
+   */
+  delay?: number;
+  /**
+   * HTTP method to match (GET, POST, PUT, PATCH, DELETE, etc.)
+   * @default 'GET'
+   */
+  method?: string;
+  /**
+   * Specific path to override URL pathname
+   * If not provided, the pathname from the URL will be used
+   */
+  path?: string;
+}
+/**
+ * Options for mocking error responses
+ */
+interface MockErrorOptions {
+  /**
+   * Custom headers to include in the error response
+   */
+  headers?: Record<string, string>;
+  /**
+   * HTTP method to match (GET, POST, PUT, PATCH, DELETE, etc.)
+   * @default 'GET'
+   */
+  method?: string;
+  /**
+   * Specific path to override URL pathname
+   * If not provided, the pathname from the URL will be used
+   */
+  path?: string;
+}
+//#endregion
+export { MockErrorOptions, MockJsonOptions };
+//# sourceMappingURL=fetch-mock.types.d.mts.map

package/dist/core/http/fetch-mock.types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-mock.types.d.mts","names":[],"sources":["../../../src/core/http/fetch-mock.types.ts"],"mappings":";;AAGA;;UAAiB,eAAA;EAUA;;;;EALhB,MAAA;EAgBA;;;EAXA,OAAA,GAAU,MAAA;EAuBM;;;EAlBhB,KAAA;EAsBA;;;;EAhBA,MAAA;EA4BI;;;;EAtBJ,IAAA;AAAA;;;;UAMgB,gBAAA;;;;EAIhB,OAAA,GAAU,MAAA;;;;;EAMV,MAAA;;;;;EAMA,IAAA;AAAA"}

package/dist/core/http/mock-fetch.d.mts

@@ -0,0 +1,92 @@
+import { MockErrorOptions, MockJsonOptions } from "./fetch-mock.types.mjs";
+import { RequestHandler } from "msw";
+
+//#region src/core/http/mock-fetch.d.ts
+/**
+ * MSW-based fetch mock for declarative HTTP mocking in tests.
+ *
+ * Replaces the old Cloudflare `fetchMock` (undici MockAgent) with MSW's `setupServer`.
+ * Works in both Node.js and workerd test environments.
+ *
+ * @example
+ * ```typescript
+ * import { createMockFetch } from '@stratal/testing'
+ *
+ * const mock = createMockFetch()
+ *
+ * beforeAll(() => mock.listen())
+ * afterEach(() => mock.reset())
+ * afterAll(() => mock.close())
+ *
+ * it('should mock external API', async () => {
+ *   mock.mockJsonResponse('https://api.example.com/data', { success: true })
+ *
+ *   const response = await fetch('https://api.example.com/data')
+ *   const json = await response.json()
+ *
+ *   expect(json.success).toBe(true)
+ * })
+ * ```
+ */
+declare class MockFetch {
+  private server;
+  constructor(handlers?: RequestHandler[]);
+  /** Start intercepting. Call in beforeAll/beforeEach. */
+  listen(): void;
+  /** Reset runtime handlers. Call in afterEach. */
+  reset(): void;
+  /** Stop intercepting. Call in afterAll. */
+  close(): void;
+  /** Add runtime handler(s) for a single test. */
+  use(...handlers: RequestHandler[]): void;
+  /**
+   * Mock a JSON response.
+   *
+   * @param url - Full URL to mock (e.g., 'https://api.example.com/users')
+   * @param data - JSON data to return
+   * @param options - HTTP method, status code, headers
+   *
+   * @example
+   * ```typescript
+   * mock.mockJsonResponse('https://api.example.com/users', { users: [] })
+   * mock.mockJsonResponse('https://api.example.com/users', { created: true }, { method: 'POST', status: 201 })
+   * ```
+   */
+  mockJsonResponse(url: string, data: Record<string, unknown> | unknown[], options?: MockJsonOptions): void;
+  /**
+   * Mock an error response.
+   *
+   * @param url - Full URL to mock
+   * @param status - HTTP error status code
+   * @param message - Optional error message
+   * @param options - HTTP method, headers
+   *
+   * @example
+   * ```typescript
+   * mock.mockError('https://api.example.com/fail', 401, 'Unauthorized')
+   * mock.mockError('https://api.example.com/fail', 500, 'Server Error', { method: 'POST' })
+   * ```
+   */
+  mockError(url: string, status: number, message?: string, options?: MockErrorOptions): void;
+}
+/**
+ * Factory function to create a new MockFetch instance
+ *
+ * @param handlers - Optional initial MSW request handlers
+ * @returns A new MockFetch instance
+ *
+ * @example
+ * ```typescript
+ * import { createMockFetch } from '@stratal/testing'
+ *
+ * const mock = createMockFetch()
+ *
+ * beforeAll(() => mock.listen())
+ * afterEach(() => mock.reset())
+ * afterAll(() => mock.close())
+ * ```
+ */
+declare function createMockFetch(handlers?: RequestHandler[]): MockFetch;
+//#endregion
+export { MockFetch, createMockFetch };
+//# sourceMappingURL=mock-fetch.d.mts.map

package/dist/core/http/mock-fetch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-fetch.d.mts","names":[],"sources":["../../../src/core/http/mock-fetch.ts"],"mappings":";;;;;;AAgCA;;;;;;;;;;;;;;;;;;;;;;;;cAAa,SAAA;EAAA,QACH,MAAA;cAEI,QAAA,GAAU,cAAA;EA8DZ;EAzDV,MAAA,CAAA;EAyDuC;EApDvC,KAAA,CAAA;EAoDyD;EA/CzD,KAAA,CAAA;EA+CuF;EA1CvF,GAAA,CAAA,GAAO,QAAA,EAAU,cAAA;EAsEY;;;;;;;;;;;;;EArD7B,gBAAA,CAAiB,GAAA,UAAa,IAAA,EAAM,MAAA,+BAAqC,OAAA,GAAS,eAAA;;;;;;;;;;;;;;;EAyBlF,SAAA,CAAU,GAAA,UAAa,MAAA,UAAgB,OAAA,WAAkB,OAAA,GAAS,gBAAA;AAAA;;;;;;;;;;;;;;;;;;iBA4BpD,eAAA,CAAgB,QAAA,GAAW,cAAA,KAAmB,SAAA"}

package/dist/core/http/mock-fetch.mjs

@@ -0,0 +1,117 @@
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+//#region src/core/http/mock-fetch.ts
+/**
+* MSW-based fetch mock for declarative HTTP mocking in tests.
+*
+* Replaces the old Cloudflare `fetchMock` (undici MockAgent) with MSW's `setupServer`.
+* Works in both Node.js and workerd test environments.
+*
+* @example
+* ```typescript
+* import { createMockFetch } from '@stratal/testing'
+*
+* const mock = createMockFetch()
+*
+* beforeAll(() => mock.listen())
+* afterEach(() => mock.reset())
+* afterAll(() => mock.close())
+*
+* it('should mock external API', async () => {
+*   mock.mockJsonResponse('https://api.example.com/data', { success: true })
+*
+*   const response = await fetch('https://api.example.com/data')
+*   const json = await response.json()
+*
+*   expect(json.success).toBe(true)
+* })
+* ```
+*/
+var MockFetch = class {
+	server;
+	constructor(handlers = []) {
+		this.server = setupServer(...handlers);
+	}
+	/** Start intercepting. Call in beforeAll/beforeEach. */
+	listen() {
+		this.server.listen({ onUnhandledRequest: "error" });
+	}
+	/** Reset runtime handlers. Call in afterEach. */
+	reset() {
+		this.server.resetHandlers();
+	}
+	/** Stop intercepting. Call in afterAll. */
+	close() {
+		this.server.close();
+	}
+	/** Add runtime handler(s) for a single test. */
+	use(...handlers) {
+		this.server.use(...handlers);
+	}
+	/**
+	* Mock a JSON response.
+	*
+	* @param url - Full URL to mock (e.g., 'https://api.example.com/users')
+	* @param data - JSON data to return
+	* @param options - HTTP method, status code, headers
+	*
+	* @example
+	* ```typescript
+	* mock.mockJsonResponse('https://api.example.com/users', { users: [] })
+	* mock.mockJsonResponse('https://api.example.com/users', { created: true }, { method: 'POST', status: 201 })
+	* ```
+	*/
+	mockJsonResponse(url, data, options = {}) {
+		const handler = http[(options.method ?? "GET").toLowerCase()](url, () => HttpResponse.json(data, {
+			status: options.status ?? 200,
+			headers: options.headers
+		}));
+		this.server.use(handler);
+	}
+	/**
+	* Mock an error response.
+	*
+	* @param url - Full URL to mock
+	* @param status - HTTP error status code
+	* @param message - Optional error message
+	* @param options - HTTP method, headers
+	*
+	* @example
+	* ```typescript
+	* mock.mockError('https://api.example.com/fail', 401, 'Unauthorized')
+	* mock.mockError('https://api.example.com/fail', 500, 'Server Error', { method: 'POST' })
+	* ```
+	*/
+	mockError(url, status, message, options = {}) {
+		const method = (options.method ?? "GET").toLowerCase();
+		const body = message ? { error: message } : void 0;
+		this.server.use(http[method](url, () => HttpResponse.json(body, {
+			status,
+			headers: options.headers
+		})));
+	}
+};
+/**
+* Factory function to create a new MockFetch instance
+*
+* @param handlers - Optional initial MSW request handlers
+* @returns A new MockFetch instance
+*
+* @example
+* ```typescript
+* import { createMockFetch } from '@stratal/testing'
+*
+* const mock = createMockFetch()
+*
+* beforeAll(() => mock.listen())
+* afterEach(() => mock.reset())
+* afterAll(() => mock.close())
+* ```
+*/
+function createMockFetch(handlers) {
+	return new MockFetch(handlers);
+}
+//#endregion
+export { MockFetch, createMockFetch };
+
+//# sourceMappingURL=mock-fetch.mjs.map

package/dist/core/http/mock-fetch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-fetch.mjs","names":[],"sources":["../../../src/core/http/mock-fetch.ts"],"sourcesContent":["import { http, HttpResponse, type RequestHandler } from 'msw'\nimport { setupServer, type SetupServer } from 'msw/node'\nimport type { MockErrorOptions, MockJsonOptions } from './fetch-mock.types'\n\ntype HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head' | 'options'\n\n/**\n * MSW-based fetch mock for declarative HTTP mocking in tests.\n *\n * Replaces the old Cloudflare `fetchMock` (undici MockAgent) with MSW's `setupServer`.\n * Works in both Node.js and workerd test environments.\n *\n * @example\n * ```typescript\n * import { createMockFetch } from '@stratal/testing'\n *\n * const mock = createMockFetch()\n *\n * beforeAll(() => mock.listen())\n * afterEach(() => mock.reset())\n * afterAll(() => mock.close())\n *\n * it('should mock external API', async () => {\n *   mock.mockJsonResponse('https://api.example.com/data', { success: true })\n *\n *   const response = await fetch('https://api.example.com/data')\n *   const json = await response.json()\n *\n *   expect(json.success).toBe(true)\n * })\n * ```\n */\nexport class MockFetch {\n  private server: SetupServer\n\n  constructor(handlers: RequestHandler[] = []) {\n    this.server = setupServer(...handlers)\n  }\n\n  /** Start intercepting. Call in beforeAll/beforeEach. */\n  listen() {\n    this.server.listen({ onUnhandledRequest: 'error' })\n  }\n\n  /** Reset runtime handlers. Call in afterEach. */\n  reset() {\n    this.server.resetHandlers()\n  }\n\n  /** Stop intercepting. Call in afterAll. */\n  close() {\n    this.server.close()\n  }\n\n  /** Add runtime handler(s) for a single test. */\n  use(...handlers: RequestHandler[]) {\n    this.server.use(...handlers)\n  }\n\n  /**\n   * Mock a JSON response.\n   *\n   * @param url - Full URL to mock (e.g., 'https://api.example.com/users')\n   * @param data - JSON data to return\n   * @param options - HTTP method, status code, headers\n   *\n   * @example\n   * ```typescript\n   * mock.mockJsonResponse('https://api.example.com/users', { users: [] })\n   * mock.mockJsonResponse('https://api.example.com/users', { created: true }, { method: 'POST', status: 201 })\n   * ```\n   */\n  mockJsonResponse(url: string, data: Record<string, unknown> | unknown[], options: MockJsonOptions = {}) {\n    const method = (options.method ?? 'GET').toLowerCase() as HttpMethod\n    const handler = http[method](url, () =>\n      HttpResponse.json(data, {\n        status: options.status ?? 200,\n        headers: options.headers,\n      }),\n    )\n    this.server.use(handler)\n  }\n\n  /**\n   * Mock an error response.\n   *\n   * @param url - Full URL to mock\n   * @param status - HTTP error status code\n   * @param message - Optional error message\n   * @param options - HTTP method, headers\n   *\n   * @example\n   * ```typescript\n   * mock.mockError('https://api.example.com/fail', 401, 'Unauthorized')\n   * mock.mockError('https://api.example.com/fail', 500, 'Server Error', { method: 'POST' })\n   * ```\n   */\n  mockError(url: string, status: number, message?: string, options: MockErrorOptions = {}) {\n    const method = (options.method ?? 'GET').toLowerCase() as HttpMethod\n    const body = message ? { error: message } : undefined\n    this.server.use(\n      http[method](url, () =>\n        HttpResponse.json(body, { status, headers: options.headers }),\n      ),\n    )\n  }\n}\n\n/**\n * Factory function to create a new MockFetch instance\n *\n * @param handlers - Optional initial MSW request handlers\n * @returns A new MockFetch instance\n *\n * @example\n * ```typescript\n * import { createMockFetch } from '@stratal/testing'\n *\n * const mock = createMockFetch()\n *\n * beforeAll(() => mock.listen())\n * afterEach(() => mock.reset())\n * afterAll(() => mock.close())\n * ```\n */\nexport function createMockFetch(handlers?: RequestHandler[]): MockFetch {\n  return new MockFetch(handlers)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAa,YAAb,MAAuB;CACrB;CAEA,YAAY,WAA6B,EAAE,EAAE;AAC3C,OAAK,SAAS,YAAY,GAAG,SAAS;;;CAIxC,SAAS;AACP,OAAK,OAAO,OAAO,EAAE,oBAAoB,SAAS,CAAC;;;CAIrD,QAAQ;AACN,OAAK,OAAO,eAAe;;;CAI7B,QAAQ;AACN,OAAK,OAAO,OAAO;;;CAIrB,IAAI,GAAG,UAA4B;AACjC,OAAK,OAAO,IAAI,GAAG,SAAS;;;;;;;;;;;;;;;CAgB9B,iBAAiB,KAAa,MAA2C,UAA2B,EAAE,EAAE;EAEtG,MAAM,UAAU,MADA,QAAQ,UAAU,OAAO,aAAa,EACzB,WAC3B,aAAa,KAAK,MAAM;GACtB,QAAQ,QAAQ,UAAU;GAC1B,SAAS,QAAQ;GAClB,CAAC,CACH;AACD,OAAK,OAAO,IAAI,QAAQ;;;;;;;;;;;;;;;;CAiB1B,UAAU,KAAa,QAAgB,SAAkB,UAA4B,EAAE,EAAE;EACvF,MAAM,UAAU,QAAQ,UAAU,OAAO,aAAa;EACtD,MAAM,OAAO,UAAU,EAAE,OAAO,SAAS,GAAG,KAAA;AAC5C,OAAK,OAAO,IACV,KAAK,QAAQ,WACX,aAAa,KAAK,MAAM;GAAE;GAAQ,SAAS,QAAQ;GAAS,CAAC,CAC9D,CACF;;;;;;;;;;;;;;;;;;;;AAqBL,SAAgB,gBAAgB,UAAwC;AACtE,QAAO,IAAI,UAAU,SAAS"}

package/dist/core/http/test-http-client.d.mts

@@ -0,0 +1,58 @@
+import { TestHttpRequest } from "./test-http-request.mjs";
+import { TestingModule } from "../testing-module.mjs";
+
+//#region src/core/http/test-http-client.d.ts
+/**
+ * TestHttpClient
+ *
+ * Fluent HTTP client for making test requests.
+ *
+ * @example
+ * ```typescript
+ * const response = await module.http
+ *   .forHost('example.com')
+ *   .post('/api/v1/users')
+ *   .withBody({ name: 'Test' })
+ *   .send()
+ *
+ * response.assertCreated()
+ * ```
+ */
+declare class TestHttpClient {
+  private readonly module;
+  private defaultHeaders;
+  private host;
+  constructor(module: TestingModule);
+  /**
+   * Set the host for the request
+   */
+  forHost(host: string): this;
+  /**
+   * Set default headers for all requests
+   */
+  withHeaders(headers: Record<string, string>): this;
+  /**
+   * Create a GET request
+   */
+  get(path: string): TestHttpRequest;
+  /**
+   * Create a POST request
+   */
+  post(path: string): TestHttpRequest;
+  /**
+   * Create a PUT request
+   */
+  put(path: string): TestHttpRequest;
+  /**
+   * Create a PATCH request
+   */
+  patch(path: string): TestHttpRequest;
+  /**
+   * Create a DELETE request
+   */
+  delete(path: string): TestHttpRequest;
+  private createRequest;
+}
+//#endregion
+export { TestHttpClient };
+//# sourceMappingURL=test-http-client.d.mts.map

package/dist/core/http/test-http-client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-http-client.d.mts","names":[],"sources":["../../../src/core/http/test-http-client.ts"],"mappings":";;;;;;AAmBA;;;;;;;;;;;;;;cAAa,cAAA;EAAA,iBAIkB,MAAA;EAAA,QAHrB,cAAA;EAAA,QACA,IAAA;cAEqB,MAAA,EAAQ,aAAA;EAK7B;;;EAAR,OAAA,CAAQ,IAAA;EAkBR;;;EAVA,WAAA,CAAY,OAAA,EAAS,MAAA;EAiBhB;;;EAPL,GAAA,CAAI,IAAA,WAAe,eAAA;EAcA;;;EAPnB,IAAA,CAAK,IAAA,WAAe,eAAA;EAqBpB;;;EAdA,GAAA,CAAI,IAAA,WAAe,eAAA;EAkBE;;;EAXrB,KAAA,CAAM,IAAA,WAAe,eAAA;;;;EAOrB,MAAA,CAAO,IAAA,WAAe,eAAA;EAAA,QAId,aAAA;AAAA"}

package/dist/core/http/test-http-client.mjs

@@ -0,0 +1,76 @@
+import { TestHttpRequest } from "./test-http-request.mjs";
+//#region src/core/http/test-http-client.ts
+/**
+* TestHttpClient
+*
+* Fluent HTTP client for making test requests.
+*
+* @example
+* ```typescript
+* const response = await module.http
+*   .forHost('example.com')
+*   .post('/api/v1/users')
+*   .withBody({ name: 'Test' })
+*   .send()
+*
+* response.assertCreated()
+* ```
+*/
+var TestHttpClient = class {
+	defaultHeaders = new Headers();
+	host = null;
+	constructor(module) {
+		this.module = module;
+	}
+	/**
+	* Set the host for the request
+	*/
+	forHost(host) {
+		this.host = host;
+		return this;
+	}
+	/**
+	* Set default headers for all requests
+	*/
+	withHeaders(headers) {
+		for (const [key, value] of Object.entries(headers)) this.defaultHeaders.set(key, value);
+		return this;
+	}
+	/**
+	* Create a GET request
+	*/
+	get(path) {
+		return this.createRequest("GET", path);
+	}
+	/**
+	* Create a POST request
+	*/
+	post(path) {
+		return this.createRequest("POST", path);
+	}
+	/**
+	* Create a PUT request
+	*/
+	put(path) {
+		return this.createRequest("PUT", path);
+	}
+	/**
+	* Create a PATCH request
+	*/
+	patch(path) {
+		return this.createRequest("PATCH", path);
+	}
+	/**
+	* Create a DELETE request
+	*/
+	delete(path) {
+		return this.createRequest("DELETE", path);
+	}
+	createRequest(method, path) {
+		return new TestHttpRequest(method, path, this.defaultHeaders, this.module, this.host);
+	}
+};
+//#endregion
+export { TestHttpClient };
+
+//# sourceMappingURL=test-http-client.mjs.map

package/dist/core/http/test-http-client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-http-client.mjs","names":[],"sources":["../../../src/core/http/test-http-client.ts"],"sourcesContent":["import type { TestingModule } from '../testing-module'\nimport { TestHttpRequest } from './test-http-request'\n\n/**\n * TestHttpClient\n *\n * Fluent HTTP client for making test requests.\n *\n * @example\n * ```typescript\n * const response = await module.http\n *   .forHost('example.com')\n *   .post('/api/v1/users')\n *   .withBody({ name: 'Test' })\n *   .send()\n *\n * response.assertCreated()\n * ```\n */\nexport class TestHttpClient {\n  private defaultHeaders: Headers = new Headers()\n  private host: string | null = null\n\n  constructor(private readonly module: TestingModule) { }\n\n  /**\n   * Set the host for the request\n   */\n  forHost(host: string): this {\n    this.host = host\n    return this\n  }\n\n  /**\n   * Set default headers for all requests\n   */\n  withHeaders(headers: Record<string, string>): this {\n    for (const [key, value] of Object.entries(headers)) {\n      this.defaultHeaders.set(key, value)\n    }\n    return this\n  }\n\n  /**\n   * Create a GET request\n   */\n  get(path: string): TestHttpRequest {\n    return this.createRequest('GET', path)\n  }\n\n  /**\n   * Create a POST request\n   */\n  post(path: string): TestHttpRequest {\n    return this.createRequest('POST', path)\n  }\n\n  /**\n   * Create a PUT request\n   */\n  put(path: string): TestHttpRequest {\n    return this.createRequest('PUT', path)\n  }\n\n  /**\n   * Create a PATCH request\n   */\n  patch(path: string): TestHttpRequest {\n    return this.createRequest('PATCH', path)\n  }\n\n  /**\n   * Create a DELETE request\n   */\n  delete(path: string): TestHttpRequest {\n    return this.createRequest('DELETE', path)\n  }\n\n  private createRequest(method: string, path: string): TestHttpRequest {\n    return new TestHttpRequest(method, path, this.defaultHeaders, this.module, this.host)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,MAA4B;CAC1B,iBAAkC,IAAI,SAAS;CAC/C,OAA8B;CAE9B,YAAY,QAAwC;AAAvB,OAAA,SAAA;;;;;CAK7B,QAAQ,MAAoB;AAC1B,OAAK,OAAO;AACZ,SAAO;;;;;CAMT,YAAY,SAAuC;AACjD,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAChD,MAAK,eAAe,IAAI,KAAK,MAAM;AAErC,SAAO;;;;;CAMT,IAAI,MAA+B;AACjC,SAAO,KAAK,cAAc,OAAO,KAAK;;;;;CAMxC,KAAK,MAA+B;AAClC,SAAO,KAAK,cAAc,QAAQ,KAAK;;;;;CAMzC,IAAI,MAA+B;AACjC,SAAO,KAAK,cAAc,OAAO,KAAK;;;;;CAMxC,MAAM,MAA+B;AACnC,SAAO,KAAK,cAAc,SAAS,KAAK;;;;;CAM1C,OAAO,MAA+B;AACpC,SAAO,KAAK,cAAc,UAAU,KAAK;;CAG3C,cAAsB,QAAgB,MAA+B;AACnE,SAAO,IAAI,gBAAgB,QAAQ,MAAM,KAAK,gBAAgB,KAAK,QAAQ,KAAK,KAAK"}