@kubb/plugin-msw 6.2.0-canary.20261111T122007 → 6.2.1

package/dist/index.js

@@ -1,8 +1,240 @@
-import { Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, setMacros, setResolver } from "@kubb/kit";
+import { Resolver, Url, addGenerator, ast, casing, createResolver, defineExtension, defineGenerator, setMacros, setResolver, text } from "@kubb/kit";
 import { pluginFakerName } from "@kubb/plugin-faker";
 import { enumTypeName, pluginTsName } from "@kubb/plugin-ts";
 import { File, Function, jsxRenderer } from "@kubb/renderer-jsx";
 import { jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+// kubb-extension.json
+var compatibility = {
+	"kubb": ">=5.18.4",
+	"node": ">=22.22"
+};
+// package.json
+var version = "6.2.1";
+// src/generators/handlersGenerator.ts
+/**
+* Aggregate generator enabled by `pluginMsw({ handlers: true })`. Emits a
+* `handlers.ts` file that re-exports every generated handler in operation
+* order, ready to spread into `setupServer(...handlers)` or
+* `setupWorker(...handlers)`.
+*/
+const handlersGenerator = defineGenerator({
+	name: "plugin-msw",
+	operations(nodes, ctx) {
+		const { resolver, config, root } = ctx;
+		const { output, group } = ctx.options;
+		const handlersName = resolver.handler.listName();
+		const createHandlersName = resolver.resolveName({
+			key: ["handlers", "create"],
+			name: casing.camel(handlersName, { prefix: "create" })
+		});
+		const file = resolver.file({
+			name: handlersName,
+			extname: ".ts",
+			root,
+			output,
+			group: group ?? void 0
+		});
+		const handlerNames = nodes.map((node) => resolver.handler.name(node));
+		const imports = nodes.map((node, index) => {
+			const operationName = handlerNames[index];
+			const operationFile = resolver.file({
+				name: resolver.name(node.operationId),
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output,
+				group: group ?? void 0
+			});
+			return ast.factory.createImport({
+				name: [operationName],
+				root: file.path,
+				path: operationFile.path
+			});
+		});
+		const handlers = handlerNames.map((name) => `${name}(undefined, options)`);
+		return [ast.factory.createFile({
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
+			}),
+			imports,
+			sources: [ast.factory.createSource({
+				name: createHandlersName,
+				isIndexable: true,
+				isExportable: true,
+				nodes: [ast.factory.createText(`export function ${createHandlersName}(options?: { baseURL?: string }) {
+  return [${handlers.join(", ")}] as const
+}`)]
+			}), ast.factory.createSource({
+				name: handlersName,
+				isIndexable: true,
+				isExportable: true,
+				nodes: [ast.factory.createText(`export const ${handlersName} = ${createHandlersName}()`)]
+			})]
+		})];
+	}
+});
+// ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = /* @__PURE__ */ new Set([
+	"abstract",
+	"arguments",
+	"await",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return isIdentifier(name);
+}
+/**
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
+*
+* @example
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
+*/
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+// ../../internals/utils/src/codegen.ts
+/**
+* An object key, quoted only when it is not identifier-shaped. Reserved words such as `class` stay bare.
+*
+* @example
+* ```ts
+* objectKey('x-total') // "'x-total'"
+* ```
+*/
+function objectKey(name) {
+	return isIdentifier(name) ? name : text.quote(name);
+}
+/**
+* A JSON value as a JavaScript literal, with single-quoted strings and identifier keys left unquoted.
+*
+* @example
+* ```ts
+* toLiteral({ id: 1, 'x-tag': ['a'] }) // "{ id: 1, 'x-tag': ['a'] }"
+* ```
+*/
+function toLiteral(value) {
+	if (typeof value === "string") return text.quote(value);
+	if (Array.isArray(value)) return `[${value.map(toLiteral).join(", ")}]`;
+	if (value && typeof value === "object") return `{ ${Object.entries(value).map(([key, item]) => `${objectKey(key)}: ${toLiteral(item)}`).join(", ")} }`;
+	return String(value);
+}
 // ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -68,19 +300,12 @@ function resolveOperationFile(options) {
 		return file;
 	});
 }
-function baseContentType(contentType) {
-	return contentType.split(";")[0].trim().toLowerCase();
-}
 /**
-* Whether a content entry is a sequence of JSON values the adapter marks as a stream, such as `application/jsonl`,
-* `application/x-ndjson`, `application/json-seq`, or any media type with an OpenAPI 3.2 `itemSchema`.
+* How a content entry is framed as a stream: `'events'` for Server-Sent Events, `'lines'` for JSON Lines.
 */
-function isJsonLines(entry) {
-	const baseType = baseContentType(entry.contentType);
-	return Boolean(entry.stream) && baseType !== "text/event-stream" && !baseType.startsWith("multipart/");
-}
-function isJsonContentType(baseType) {
-	return baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json";
+function getStreamFraming(entry) {
+	if (ast.mediaType.getBase(entry) === "text/event-stream") return "events";
+	return entry.stream && ast.mediaType.isStream(entry) ? "lines" : void 0;
 }
 /**
 * Parser for one response content entry.
@@ -91,10 +316,10 @@ function isJsonContentType(baseType) {
 * `image/*`, `audio/*`, and `video/*` are blobs.
 */
 function responseTypeForContent(entry) {
-	const baseType = baseContentType(entry.contentType);
+	const baseType = ast.mediaType.getBase(entry);
 	if (!baseType) return void 0;
-	if (baseType === "text/event-stream" || isJsonLines(entry)) return "stream";
-	if (isJsonContentType(baseType)) return void 0;
+	if (getStreamFraming(entry)) return "stream";
+	if (ast.mediaType.isJson(baseType)) return void 0;
 	if (entry.schema?.type === "blob") return "blob";
 	if (baseType.startsWith("text/")) return "text";
 	if (isBinaryContentType(baseType)) return "blob";
@@ -111,14 +336,14 @@ function isBinaryContentType(baseType) {
 function toResponseContent(entry, entries = [entry]) {
 	const { contentType, schema } = entry;
 	if (!schema || entry.stream) return entry;
-	const baseType = baseContentType(contentType);
-	const resolved = ast.resolveRef(schema);
+	const baseType = ast.mediaType.getBase(contentType);
+	const resolved = ast.ref.getSchema(schema);
 	if (isBinaryContentType(baseType)) return resolved.type === "blob" ? entry : {
 		...entry,
 		schema: ast.factory.createSchema({ type: "blob" }),
 		keysToOmit: null
 	};
-	const isPlainMediaType = Boolean(baseType) && !isJsonContentType(baseType) && !baseType.includes("*");
+	const isPlainMediaType = Boolean(baseType) && !ast.mediaType.isJson(baseType) && !baseType.includes("*");
 	if (resolved.type === "blob") return isPlainMediaType && !entries.every((item) => item.schema?.type === "blob") ? {
 		...entry,
 		schema: ast.factory.createSchema({ type: "string" }),
@@ -134,36 +359,6 @@ function toResponseContent(entry, entries = [entry]) {
 		keysToOmit: null
 	} : entry;
 }
-function getStatusCodeNumber(statusCode) {
-	const code = Number(statusCode);
-	return Number.isNaN(code) ? null : code;
-}
-function isSuccessStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 200 && code < 300;
-}
-function getSuccessResponses(responses) {
-	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
-}
-function getOperationSuccessResponses(node) {
-	return getSuccessResponses(node.responses);
-}
-function getPrimarySuccessResponse(node) {
-	return getOperationSuccessResponses(node)[0] ?? null;
-}
-function resolveResponseTypes(node, resolver) {
-	const types = [];
-	for (const response of node.responses) {
-		if (response.statusCode === "default") {
-			types.push(["default", resolver.response.response(node)]);
-			continue;
-		}
-		const code = getStatusCodeNumber(response.statusCode);
-		if (code === null) continue;
-		types.push([code, isSuccessStatusCode(code) ? resolver.response.response(node) : resolver.response.status(node, response.statusCode)]);
-	}
-	return types;
-}
 // ../../internals/shared/src/resolver.ts
 /**
 * Builds the allocation key for a declaration an operation owns. `scope` names which declaration
@@ -191,124 +386,25 @@ function operationKey(node, ...scope) {
 function getEnumNames(ctx) {
 	return ctx.memo("enumNames:set", () => new Set((ctx.driver.inputNode?.schemas ?? []).flatMap((schema) => schema.type === "enum" && schema.name ? [schema.name] : [])));
 }
-// ../../internals/shared/src/group.ts
-/**
-* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
-* shared default naming so every plugin groups output consistently:
-*
-* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
-* - other groups use the camelCased group (`pet store` → `petStore`).
-*
-* A user-provided `group.name` always wins over the default namer, so callers stay in
-* control of their output folders. Returns `null` when grouping is disabled, matching the
-* per-plugin convention.
-*
-* @param group - The user-supplied group option, or `undefined` to disable grouping.
-*
-* @example
-* ```ts
-* createGroupConfig(group) // shared across every plugin
-* ```
-*/
-function createGroupConfig(group) {
-	if (!group) return null;
-	const defaultName = (ctx) => {
-		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return camelCase(ctx.group);
-	};
-	return {
-		...group,
-		name: group.name ? group.name : defaultName
-	};
+// src/utils.ts
+function toSimpleStyle(value) {
+	if (Array.isArray(value)) return value.join(",");
+	if (typeof value === "object" && value !== null) return Object.entries(value).flat().join(",");
+	return String(value);
 }
-// kubb-extension.json
-var compatibility = {
-	"kubb": ">=5.16.0",
-	"node": ">=22.22"
-};
-// package.json
-var version = "6.2.0-canary.20261111T122007";
-// src/generators/handlersGenerator.ts
 /**
-* Aggregate generator enabled by `pluginMsw({ handlers: true })`. Emits a
-* `handlers.ts` file that re-exports every generated handler in operation
-* order, ready to spread into `setupServer(...handlers)` or
-* `setupWorker(...handlers)`.
+* The declared headers a mock sends, each with its example's `serializedValue` or `value`, else its schema's `default` or first example.
 */
-const handlersGenerator = defineGenerator({
-	name: "plugin-msw",
-	operations(nodes, ctx) {
-		const { resolver, config, root } = ctx;
-		const { output, group } = ctx.options;
-		const handlersName = resolver.handler.listName();
-		const createHandlersName = resolver.resolveName({
-			key: ["handlers", "create"],
-			name: camelCase(handlersName, { prefix: "create" })
-		});
-		const file = resolver.file({
-			name: handlersName,
-			extname: ".ts",
-			root,
-			output,
-			group: group ?? void 0
-		});
-		const handlerNames = nodes.map((node) => resolver.handler.name(node));
-		const imports = nodes.map((node, index) => {
-			const operationName = handlerNames[index];
-			const operationFile = resolver.file({
-				name: resolver.name(node.operationId),
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
-				root,
-				output,
-				group: group ?? void 0
-			});
-			return ast.factory.createImport({
-				name: [operationName],
-				root: file.path,
-				path: operationFile.path
-			});
-		});
-		const handlers = handlerNames.map((name) => `${name}(undefined, options)`);
-		return [ast.factory.createFile({
-			baseName: file.baseName,
-			path: file.path,
-			meta: file.meta,
-			banner: resolver.default.banner(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: file.path,
-					baseName: file.baseName
-				}
-			}),
-			footer: resolver.default.footer(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: file.path,
-					baseName: file.baseName
-				}
-			}),
-			imports,
-			sources: [ast.factory.createSource({
-				name: createHandlersName,
-				isIndexable: true,
-				isExportable: true,
-				nodes: [ast.factory.createText(`export function ${createHandlersName}(options?: { baseURL?: string }) {
-  return [${handlers.join(", ")}] as const
-}`)]
-			}), ast.factory.createSource({
-				name: handlersName,
-				isIndexable: true,
-				isExportable: true,
-				nodes: [ast.factory.createText(`export const ${handlersName} = ${createHandlersName}()`)]
-			})]
-		})];
-	}
-});
-// src/utils.ts
+function getMockHeaders(response) {
+	return (response?.headers ?? []).flatMap((header) => {
+		if (header.name.toLowerCase() === "content-type") return [];
+		const example = header.examples?.find((entry) => entry.serializedValue !== void 0 || entry.value !== void 0);
+		const headerValue = example?.serializedValue ?? example?.value ?? header.schema.default ?? header.schema.examples?.[0];
+		if (headerValue === void 0 || headerValue === null) return [];
+		const headerText = toSimpleStyle(headerValue);
+		return /^[\t\x20-\x7E\x80-\xFF]*$/.test(headerText) ? [[header.name, headerText]] : [];
+	});
+}
 /**
 * Returns the base URL as source code. A `${...}` value stays a template literal.
 */
@@ -336,13 +432,12 @@ function hasResponseSchema(response) {
 * content types, JSON is preferred (the faker mock body is JSON), otherwise the first declared type.
 */
 function getResponseContentType(response) {
-	const contents = response?.content ?? [];
-	const value = (contents.find((entry) => isJson(entry.contentType)) ?? contents[0])?.contentType;
-	return typeof value === "string" && value.length > 0 ? value : null;
+	const contentType = getResponseEntry(response)?.contentType;
+	return typeof contentType === "string" && contentType.length > 0 ? contentType : null;
 }
-function isJson(contentType) {
-	const baseType = contentType?.split(";")[0]?.trim().toLowerCase();
-	return baseType === "application/json" || Boolean(baseType?.endsWith("+json"));
+function getResponseEntry(response) {
+	const contents = response?.content ?? [];
+	return contents.find((entry) => ast.mediaType.isJson(entry)) ?? contents[0];
 }
 /**
 * The first content type of a response that the client reads as text, such as `application/xml`, or `null` when none is.
@@ -350,49 +445,109 @@ function isJson(contentType) {
 function getTextContentType(response) {
 	return (response?.content ?? []).find((entry) => {
 		const schema = toResponseContent(entry, response?.content).schema;
-		return !isJson(entry.contentType) && schema && ast.resolveRef(schema).primitive === "string";
+		return !ast.mediaType.isJson(entry) && schema && ast.ref.getSchema(schema).primitive === "string";
 	})?.contentType ?? null;
 }
+const bigintReplacer = `(_key, value) => {
+      if (typeof value !== 'bigint') return value
+      if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) throw new TypeError(\`Cannot serialize \${value}n as JSON without losing precision.\`)
+      return Number(value)
+    }`;
+/** The `JSON.stringify` call for `body`, with a replacer when the response holds an `int64`, which `JSON.stringify` throws on. */
+function stringify(body, response) {
+	return (response?.content ?? []).some((entry) => entry.schema && ast.schema.find(entry.schema, {
+		predicate: (schema) => schema.type === "bigint",
+		followRefs: true
+	}) !== void 0) ? `JSON.stringify(${body}, ${bigintReplacer})` : `JSON.stringify(${body})`;
+}
 /**
 * The statements that return a mocked `Response` for `body`. A string body for a response the client reads as text goes
 * out as raw text with that content type, so an XML mock is not sent as a quoted JSON string. Any other body is JSON.
 */
 function responseReturn(body, status, response) {
 	const contentType = getContentType(response);
+	const headers = getMockHeaders(response);
+	const name = isValidVarName(body) ? body : "body";
+	const prelude = name === body ? "" : `const body = ${body}\n    `;
+	if (contentType && ast.mediaType.getBase(contentType) === "text/event-stream") {
+		const entry = getResponseEntry(response);
+		const serialized = entry?.examples?.find((example) => example.serializedValue !== void 0)?.serializedValue;
+		const fallback = serialized === void 0 ? "''" : toLiteral(serialized);
+		if (entry?.stream?.shape !== "event") return `${prelude}return ${responseLiteral(`${name} === undefined ? ${fallback} : \`\${${eventDataLines(name, response)}}\\n\\n\``, status, contentType, headers)}`;
+		return `${prelude}const event = ${name} as { event?: unknown; id?: unknown; retry?: unknown; data?: unknown } | undefined
+    const lines = [
+      ...(['event', 'id', 'retry'] as const).filter((field) => event?.[field] !== undefined).map((field) => \`\${field}: \${event?.[field]}\`),
+      // A client dispatches an event only once it has a \`data\` line, so an event without data still sends an empty one.
+      event?.data === undefined ? 'data:' : ${eventDataLines("event.data", response)},
+    ]
+
+    return ${responseLiteral(`event === undefined ? ${fallback} : \`\${lines.join('\\n')}\\n\\n\``, status, contentType, headers)}`;
+	}
 	const textContentType = hasResponseSchema(response) ? getTextContentType(response) : null;
-	if (!textContentType) return `return ${responseLiteral(`JSON.stringify(${body})`, status, contentType)}`;
-	const name = /^\w+$/.test(body) ? body : "body";
-	return `${name === body ? "" : `const body = ${body}\n    `}if (typeof ${name} === 'string') return ${responseLiteral(name, status, textContentType)}
+	if (!textContentType) return `return ${responseLiteral(stringify(body, response), status, contentType, headers)}`;
+	return `${prelude}if (typeof ${name} === 'string') return ${responseLiteral(name, status, textContentType, headers)}
 
-    return ${responseLiteral(`JSON.stringify(${name})`, status, contentType)}`;
+    return ${responseLiteral(stringify(name, response), status, contentType, headers)}`;
+}
+/**
+* The `data:` lines of one Server-Sent Event. A string goes out as it is, since a client keeps string `data` as text.
+*/
+function eventDataLines(body, response) {
+	return `(typeof ${body} === 'string' ? ${body} : ${stringify(body, response)}).split('\\n').map((line) => \`data: \${line}\`).join('\\n')`;
 }
 /**
-* Converts an HTTP method to its lowercase MSW equivalent (e.g., 'POST' → 'post'). MSW has no
-* `http.query`, so a QUERY operation maps to `http.all` and its handler checks the method itself.
+* The spec example of the response entry the mock sends, as source code, or `null` when that entry has none.
+*/
+function getExampleBody(response) {
+	const entry = getResponseEntry(response);
+	const example = entry?.examples?.find((item) => item.value !== void 0 || item.serializedValue !== void 0);
+	if (!entry || !example) return null;
+	if (example.value !== void 0) return toLiteral(example.value);
+	if (!ast.mediaType.isJson(entry)) return ast.mediaType.getBase(entry) !== "text/event-stream" && getTextContentType(response) === entry.contentType ? toLiteral(example.serializedValue) : null;
+	try {
+		return toLiteral(JSON.parse(example.serializedValue));
+	} catch {
+		return null;
+	}
+}
+const mswMethods = /* @__PURE__ */ new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"HEAD",
+	"OPTIONS"
+]);
+/**
+* Converts an HTTP method to its lowercase MSW equivalent (e.g., 'POST' → 'post'). MSW has no `http.query`, `http.trace` or
+* handler for a custom `additionalOperations` method, so such an operation maps to `http.all` and its handler checks the
+* method itself.
 */
 function getMswMethod(node) {
-	return node.method === "QUERY" ? "all" : node.method.toLowerCase();
+	return mswMethods.has(node.method) ? node.method.toLowerCase() : "all";
 }
 /**
-* The `headers` entry of a mocked `Response` init, or an empty string when there is no content type.
+* The `headers` entry of a mocked `Response` init, or an empty string when there is no header to send.
 */
-function headersBlock(contentType) {
-	return contentType ? `\n      headers: {\n        'Content-Type': '${contentType}'\n      },` : "";
+function headersBlock(contentType, headers) {
+	const entries = [...contentType ? [`'Content-Type': ${text.quote(contentType)}`] : [], ...headers.map(([name, value]) => `${text.quote(name)}: ${text.quote(value)}`)];
+	return entries.length ? `\n      headers: {\n        ${entries.join(",\n        ")}\n      },` : "";
 }
 /**
 * The `new HttpResponse<string>(...)` expression a mocked handler returns.
 */
-function responseLiteral(body, status, contentType) {
+function responseLiteral(body, status, contentType, headers) {
 	return `new HttpResponse<string>(${body}, {
-      status: ${status},${headersBlock(contentType)}
+      status: ${status},${headersBlock(contentType, headers)}
     })`;
 }
 // src/components/Mock.tsx
-function Mock({ baseURL = "", name, fakerName, typeName, requestTypeName, node }) {
+function Mock({ baseURL = "", name, fakerName, responseName, typeName, requestTypeName, node }) {
 	const method = getMswMethod(node);
-	const methodGuard = node.method === "QUERY" ? `if (info.request.method !== 'QUERY') return\n\n    ` : "";
-	const successResponse = getPrimarySuccessResponse(node);
-	const statusCode = successResponse ? Number(successResponse.statusCode) : 200;
+	const methodGuard = method === "all" ? `if (info.request.method !== ${text.quote(node.method)}) return\n\n    ` : "";
+	const successResponse = ast.http.responses.findPrimary(node);
+	const statusCode = successResponse ? ast.http.status.toCode(successResponse) : 200;
 	const url = Url.toPath(node.path);
 	const dataType = hasResponseSchema(successResponse) ? typeName : "string | number | boolean | null | object";
 	const paramType = fakerName ? typeName : dataType;
@@ -400,7 +555,10 @@ function Mock({ baseURL = "", name, fakerName, typeName, requestTypeName, node }
 	const params = `data?: ${paramType} | ${requestBodyType ? `HttpResponseResolver<Record<string, string>, ${requestBodyType}>` : `((info: Parameters<Parameters<typeof http.${method}>[1]>[0]) => Response | Promise<Response>)`}, options?: { baseURL?: string }`;
 	const httpCall = requestBodyType ? `http.${method}<Record<string, string>, ${requestBodyType}>` : `http.${method}`;
 	const urlLiteral = `\`\${options?.baseURL ?? ${resolveDefaultBaseURL(baseURL)}}${url.replace(/([^/]):/g, "$1\\\\:")}\``;
-	const responseBody = fakerName ? `data ?? ${fakerName}(data)` : "data";
+	const example = fakerName ? null : getExampleBody(successResponse);
+	const exampleBody = example ? `data === undefined ? ${example} : data` : "data";
+	const responseBody = fakerName ? `data ?? ${fakerName}()` : exampleBody;
+	const responseStatements = responseName && !example ? `return ${responseName}(${responseBody})` : responseReturn(responseBody, statusCode, successResponse);
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isIndexable: true,
@@ -412,16 +570,15 @@ function Mock({ baseURL = "", name, fakerName, typeName, requestTypeName, node }
 			children: `return ${httpCall}(${urlLiteral}, function handler(info) {
     ${methodGuard}if(typeof data === 'function') return data(info)
 
-    ${responseReturn(responseBody, statusCode, successResponse)}
+    ${responseStatements}
   })`
 		})
 	});
 }
 // src/components/Response.tsx
 function Response({ name, typeName, response }) {
-	const statusCode = Number(response.statusCode);
-	const params = `data${hasResponseSchema(response) ? "" : "?"}: ${typeName}`;
-	const responseName = `${name}Response${statusCode}`;
+	const params = `data?: ${typeName}`;
+	const responseName = `${name}Response${response.statusCode}`;
 	return /* @__PURE__ */ jsx(File.Source, {
 		name: responseName,
 		isIndexable: true,
@@ -431,7 +588,7 @@ function Response({ name, typeName, response }) {
 			export: true,
 			params,
 			children: `
-    ${responseReturn("data", statusCode, response)}`
+    ${responseReturn("data", ast.http.status.toCode(response), response)}`
 		})
 	});
 }
@@ -446,7 +603,7 @@ const mswGenerator = defineGenerator({
 	name: "msw",
 	renderer: jsxRenderer,
 	operation(node, ctx) {
-		if (!ast.isHttpOperationNode(node)) return null;
+		if (!ast.http.isOperation(node)) return null;
 		const { driver, resolver, config, root } = ctx;
 		const { output, parser, baseURL, group } = ctx.options;
 		const fileName = resolver.name(node.operationId);
@@ -488,8 +645,8 @@ const mswGenerator = defineGenerator({
 			}),
 			responseName: tsResolver.response.response(node)
 		};
-		const successResponses = getOperationSuccessResponses(node);
-		const referencedNames = node.responses.flatMap((response) => (response.content ?? []).flatMap((entry) => entry.schema ? ast.collectImportedRefNames(entry.schema) : []));
+		const successResponses = ast.http.responses.filterSuccess(node);
+		const referencedNames = ast.http.responses.getImportedNames(node.responses);
 		const enumOptions = pluginTs.options?.enum;
 		const enumNames = getEnumNames(ctx);
 		const hasResponseNameCollision = referencedNames.some((name) => {
@@ -500,14 +657,15 @@ const mswGenerator = defineGenerator({
 				isEnum: enumNames.has(name)
 			}) === type.responseName;
 		});
-		const types = resolveResponseTypes(node, tsResolver).map(([code, typeName]) => {
-			const successResponse = successResponses.find((response) => response.statusCode === String(code));
-			return [code, hasResponseNameCollision && successResponse ? tsResolver.response.status(node, successResponse.statusCode) : typeName];
+		const types = node.responses.filter((response) => response.statusCode !== "default" && ast.http.status.getClass(response) !== 1).map((response) => {
+			return [response, ast.http.status.isSuccess(response) && !hasResponseNameCollision ? type.responseName : tsResolver.response.status(node, response.statusCode)];
 		});
-		const responseTypeNames = types.map(([, typeName]) => typeName).filter((name) => !hasResponseNameCollision || name !== type.responseName);
+		const responseTypeNames = types.map(([, typeName]) => typeName);
 		const mockResponseName = hasResponseNameCollision && successResponses[0] ? tsResolver.response.status(node, successResponses[0].statusCode) : type.responseName;
 		const hasSuccessSchema = successResponses.some((response) => hasResponseSchema(response));
-		const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.response.body(node) : null;
+		const primaryResponse = ast.http.responses.findPrimary(node);
+		const responseHelperName = primaryResponse && hasResponseSchema(primaryResponse) && types.some(([response, typeName]) => response.statusCode === primaryResponse.statusCode && typeName === mockResponseName) ? `${mock.name}Response${primaryResponse.statusCode}` : void 0;
+		const requestName = ast.http.requestBody.getSchema(node) ? tsResolver.response.body(node) : null;
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: mock.file.baseName,
 			path: mock.file.path,
@@ -558,20 +716,17 @@ const mswGenerator = defineGenerator({
 					root: mock.file.path,
 					path: faker.file.path
 				}),
-				types.filter(([code]) => code !== "default").map(([code, typeName]) => {
-					const response = node.responses.find((item) => item.statusCode === String(code));
-					if (!response) return null;
-					return /* @__PURE__ */ jsx(Response, {
-						typeName,
-						response,
-						name: mock.name
-					}, typeName);
-				}),
+				types.map(([response, typeName]) => /* @__PURE__ */ jsx(Response, {
+					typeName,
+					response,
+					name: mock.name
+				}, response.statusCode)),
 				/* @__PURE__ */ jsx(Mock, {
 					name: mock.name,
 					typeName: mockResponseName,
 					requestTypeName: requestName,
 					fakerName: faker && hasSuccessSchema ? faker.name : void 0,
+					responseName: responseHelperName,
 					node,
 					baseURL
 				})
@@ -598,7 +753,7 @@ const mswGenerator = defineGenerator({
 const resolverMsw = createResolver({
 	pluginName: "plugin-msw",
 	name(name) {
-		return this.memo(`name:${name}`, () => camelCase(name, { suffix: "handler" }));
+		return this.memo(`name:${name}`, () => casing.camel(name, { suffix: "handler" }));
 	},
 	handler: {
 		name(node) {
@@ -673,7 +828,7 @@ const pluginMsw = defineExtension({
 			output,
 			parser,
 			baseURL,
-			group: createGroupConfig(group),
+			group: group ?? null,
 			exclude,
 			include,
 			override,