vite-plugin-openapi-codegen 1.1.2 → 1.2.0

package/README.md

@@ -8,7 +8,7 @@ The plugin reads your OpenAPI JSON or YAML spec, runs `openapi-typescript`, and
 - `api.ts` for path builder functions
 - `client.ts` for typed request helpers
 
-It also watches local input specs in dev mode and regenerates the files when the spec changes. In dev mode, generation runs in the background so Vite can finish starting even if the remote spec is temporarily unavailable. Online `http://` and `https://` inputs are fetched once when Vite starts. Build mode skips the plugin entirely.
+It also regenerates local input specs through Vite HMR when the spec changes. In dev mode, generation runs in the background so Vite can finish starting even if the remote spec is temporarily unavailable. Online `http://` and `https://` inputs are fetched once when Vite starts. Build mode skips the plugin entirely. For manual generation, the package also ships a `vg` CLI that reads your local `vite.config.*` and runs the same generator once.
 
 ## Installation
 
@@ -36,6 +36,22 @@ export default defineConfig({
 });
 ```
 
+If you want to reuse the same configuration outside Vite, run the CLI from the project root:
+
+```bash
+vg
+```
+
+By default, `vg` searches for `vite.config.ts`, `vite.config.mts`, `vite.config.js`, `vite.config.mjs`, `vite.config.cjs`, or `vite.config.cts` in the current working directory. It reads the `openapiCodegen(...)` plugin options from that file, then generates once with those values.
+
+You can also pass explicit flags. CLI flags always win over the config file:
+
+```bash
+vg --root ./example/local
+vg --input openapi.yaml --output src/generated
+vg --path-prefix /v1/ --type-aliases
+```
+
 Online YAML inputs use the same option:
 
 ```ts
@@ -209,6 +225,8 @@ The generated client shape depends on the OpenAPI operation:
 - path parameters become `options.path`
 - query parameters become `options.query`
 - JSON request bodies become `options.body`
+- `application/octet-stream` request bodies become `options.body` with `contentType: "application/octet-stream"`
+- `multipart/form-data` request bodies become `options.body` as `FormData`
 - JSON responses become typed `Promise<T>`
 - empty responses use the configured void request function
 
@@ -233,29 +251,29 @@ interface Options {
 
 ### `input`
 
-Path or URL to the OpenAPI JSON/YAML document. Local paths are resolved relative to the Vite project root and watched in dev mode. Online `http://` and `https://` URLs are fetched once at startup and are not watched.
+Path or URL to the OpenAPI JSON/YAML document. Local paths are resolved relative to the Vite project root and watched in dev mode. Online `http://` and `https://` URLs are fetched once at startup and are not watched. The `vg` CLI reads this value from `vite.config.*` when present, unless you override it with `--input`.
 
 In dev mode, generation errors are logged and do not stop Vite from starting. In build mode, the plugin is skipped entirely.
 
 ### `output`
 
-Directory where generated files are written, relative to the Vite project root.
+Directory where generated files are written, relative to the Vite project root. The `vg` CLI reads this value from `vite.config.*` when present, unless you override it with `--output`.
 
 ### `pathPrefix`
 
-Only paths starting with this prefix are included. The default is `"/api/"`.
+Only paths starting with this prefix are included. The default is `"/api/"`. The `vg` CLI reads this value from `vite.config.*` when present, unless you override it with `--path-prefix`.
 
 ### `stripPrefix`
 
-Controls whether the `pathPrefix` is removed from generated path builders. The default is `true`.
+Controls whether the `pathPrefix` is removed from generated path builders. The default is `true`. The `vg` CLI reads this value from `vite.config.*` when present, unless you override it with `--strip-prefix` or `--no-strip-prefix`.
 
 ### `typeAliases`
 
-When enabled, the plugin generates top-level aliases for schema and operation types and makes the emitted `api.ts` and `client.ts` import those shorter names. The suffixes stay intact, so generated names remain readable while avoiding long `components["schemas"][...]` and `operations["..."][...]` chains. The default is `false` to preserve existing output.
+When enabled, the plugin generates top-level aliases for schema and operation types and makes the emitted `api.ts` and `client.ts` import those shorter names. The suffixes stay intact, so generated names remain readable while avoiding long `components["schemas"][...]` and `operations["..."][...]` chains. The default is `false` to preserve existing output. The `vg` CLI reads this value from `vite.config.*` when present, unless you override it with `--type-aliases` or `--no-type-aliases`.
 
 ### `httpClient`
 
-Overrides the runtime import path and symbol names used by generated clients.
+Overrides the runtime import path and symbol names used by generated clients. The `vg` CLI reads this object from `vite.config.*` when present, unless you override the corresponding HTTP client flags.
 
 ## Programmatic Usage
 

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,848 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { loadConfigFromFile } from "vite-plus";
+import { pathToFileURL } from "node:url";
+import { parse } from "yaml";
+import * as ts from "typescript";
+//#region src/ast.ts
+const AST_PRINTER = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+function renderApiSource(entries, generatedHeader) {
+	const statements = [];
+	const seenGroups = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		const parameters = entry.pathTypeExpr == null ? [] : [ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("params"), void 0, createTypeNodeFromText(entry.pathTypeExpr))];
+		const declaration = ts.factory.createFunctionDeclaration([createExportModifier()], void 0, ts.factory.createIdentifier(entry.funcName), void 0, parameters, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), ts.factory.createBlock([ts.factory.createReturnStatement(entry.pathTypeExpr == null ? ts.factory.createStringLiteral(entry.strippedPath) : createPathExpression(entry.strippedPath))], true));
+		statements.push(seenGroups.has(entry.group) ? declaration : createGeneratedBannerComment(declaration, capitalize$1(entry.group)));
+		seenGroups.add(entry.group);
+	}
+	const sourceStatements = [];
+	const apiTypeImports = collectApiTypeImports(entries.map((entry) => entry.pathTypeExpr));
+	if (apiTypeImports.length > 0) sourceStatements.push(createTypeOnlyImport(apiTypeImports, "./api-types"));
+	sourceStatements.push(...statements);
+	return printGeneratedFile(sourceStatements, generatedHeader);
+}
+function renderClientSource(model, generatedHeader, httpClient) {
+	const statements = [createTypeOnlyImport([httpClient.requestOptionsType], httpClient.module), createValueImport([{ name: httpClient.jsonFunction }, { name: httpClient.voidFunction }], httpClient.module)];
+	const apiTypeImports = collectApiTypeImports(model.operations.flatMap((operation) => [
+		operation.bodyChannel.typeRef?.sourceExpr,
+		operation.pathChannel.typeRef?.sourceExpr,
+		operation.queryChannel.typeRef?.sourceExpr,
+		operation.responseTypeExpr,
+		operation.returnTypeExpr
+	]));
+	if (apiTypeImports.length > 0) statements.push(createTypeOnlyImport(apiTypeImports, "./api-types"));
+	statements.push(createValueImport(model.operations.map((operation) => ({
+		alias: operation.builderAlias,
+		name: operation.funcName
+	})), "./api"));
+	const runtimeTypeExpr = httpClient.omitKeys.length > 0 ? `Omit<${httpClient.requestOptionsType}, ${httpClient.omitKeys.map((k) => `'${k}'`).join(" | ")}>` : httpClient.requestOptionsType;
+	statements.push(ts.factory.createTypeAliasDeclaration(void 0, ts.factory.createIdentifier("RuntimeRequestOptions"), void 0, createTypeNodeFromText(runtimeTypeExpr)));
+	if (model.needsSearchParamsHelper) statements.push(createBuildSearchParamsFunction());
+	const seenGroups = /* @__PURE__ */ new Set();
+	for (const operation of model.operations) {
+		const optionsInterface = createClientOptionsDeclaration(operation);
+		statements.push(seenGroups.has(operation.group) ? optionsInterface : createGeneratedBannerComment(optionsInterface, capitalize$1(operation.group)));
+		statements.push(createClientFunctionDeclaration(operation));
+		seenGroups.add(operation.group);
+	}
+	return printGeneratedFile(statements, generatedHeader);
+}
+function renderOperationTypeAliases(typeAliases) {
+	if (typeAliases.length === 0) return "";
+	return `${typeAliases.map((alias) => `export type ${alias.typeName} = ${alias.definitionExpr};`).join("\n")}\n`;
+}
+function printGeneratedFile(statements, generatedHeader) {
+	const sourceFile = ts.factory.createSourceFile(statements, ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+	const printed = AST_PRINTER.printFile(sourceFile).trim();
+	return printed.length > 0 ? `${generatedHeader.join("\n")}\n\n${printed}\n` : `${generatedHeader.join("\n")}\n`;
+}
+function parseExpression(sourceText) {
+	const statement = ts.createSourceFile("generated-expression.ts", `const value = ${sourceText}`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).statements[0];
+	if (!statement || !ts.isVariableStatement(statement)) throw new Error(`Failed to parse expression: ${sourceText}`);
+	const declaration = statement.declarationList.declarations[0];
+	if (!declaration?.initializer) throw new Error(`Missing parsed initializer for: ${sourceText}`);
+	return declaration.initializer;
+}
+function createTypeOnlyImport(names, moduleSpecifier) {
+	return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports(names.map((name) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(name))))), ts.factory.createStringLiteral(moduleSpecifier));
+}
+function createValueImport(specifiers, moduleSpecifier) {
+	return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(specifiers.map((specifier) => ts.factory.createImportSpecifier(false, specifier.alias ? ts.factory.createIdentifier(specifier.name) : void 0, ts.factory.createIdentifier(specifier.alias ?? specifier.name))))), ts.factory.createStringLiteral(moduleSpecifier));
+}
+function createExportModifier() {
+	return ts.factory.createModifier(ts.SyntaxKind.ExportKeyword);
+}
+function createGeneratedBannerComment(node, text) {
+	return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.SingleLineCommentTrivia, ` ${text}`, true);
+}
+function collectApiTypeImports(typeExprs) {
+	const names = /* @__PURE__ */ new Set();
+	for (const typeExpr of typeExprs) {
+		if (!typeExpr) continue;
+		if (typeExpr.includes("components[")) names.add("components");
+		if (typeExpr.includes("operations[")) {
+			names.add("operations");
+			continue;
+		}
+		const name = typeExpr.trim();
+		if (/^[A-Za-z_$][\w$]*$/.test(name) && !isBuiltinTypeName(name)) names.add(name);
+	}
+	return [...names].sort();
+}
+function isBuiltinTypeName(name) {
+	return new Set([
+		"AbortSignal",
+		"Array",
+		"Blob",
+		"Date",
+		"Error",
+		"File",
+		"FormData",
+		"Map",
+		"Omit",
+		"Promise",
+		"Record",
+		"Set",
+		"URLSearchParams",
+		"boolean",
+		"never",
+		"null",
+		"number",
+		"object",
+		"string",
+		"undefined",
+		"unknown",
+		"void"
+	]).has(name);
+}
+function createPathExpression(strippedPath) {
+	const matches = [...strippedPath.matchAll(/\{(\w+)\}/g)];
+	if (matches.length === 0) return ts.factory.createStringLiteral(strippedPath);
+	const [firstMatch] = matches;
+	const spans = matches.map((match, index) => {
+		const nextMatch = matches[index + 1];
+		const literalText = strippedPath.slice(match.index + match[0].length, nextMatch?.index ?? strippedPath.length);
+		return ts.factory.createTemplateSpan(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("params"), match[1]), nextMatch ? ts.factory.createTemplateMiddle(literalText) : ts.factory.createTemplateTail(literalText));
+	});
+	return ts.factory.createTemplateExpression(ts.factory.createTemplateHead(strippedPath.slice(0, firstMatch.index)), spans);
+}
+function createTypeNodeFromText(sourceText) {
+	const stmt = ts.createSourceFile("__type__.ts", `type __T__ = ${sourceText}`, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS).statements[0];
+	if (!stmt || !ts.isTypeAliasDeclaration(stmt)) throw new Error(`Failed to parse type expression: ${sourceText}`);
+	return stmt.type;
+}
+function createClientOptionsDeclaration(operation) {
+	return ts.factory.createInterfaceDeclaration([createExportModifier()], ts.factory.createIdentifier(operation.optionTypeName), void 0, void 0, [
+		createClientChannelField("query", operation.queryChannel),
+		createClientChannelField("path", operation.pathChannel),
+		createClientChannelField("body", operation.bodyChannel),
+		ts.factory.createPropertySignature(void 0, ts.factory.createIdentifier("signal"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode("AbortSignal"))
+	]);
+}
+function createClientChannelField(key, channel) {
+	return ts.factory.createPropertySignature(void 0, ts.factory.createIdentifier(key), channel.present && channel.required ? void 0 : ts.factory.createToken(ts.SyntaxKind.QuestionToken), channel.present && channel.typeRef ? createTypeNodeFromText(channel.typeRef.sourceExpr) : ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword));
+}
+function createClientFunctionDeclaration(operation) {
+	const requestProperties = [ts.factory.createSpreadAssignment(ts.factory.createIdentifier("requestOptions")), ts.factory.createPropertyAssignment(ts.factory.createIdentifier("method"), ts.factory.createStringLiteral(operation.methodUpper))];
+	if (operation.queryChannel.present) requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("searchParams"), ts.factory.createCallExpression(ts.factory.createIdentifier("buildSearchParams"), void 0, [ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "query")])));
+	if (operation.bodyChannel.present) {
+		if (operation.bodyContentType === "json") requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("json"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "body")));
+		else requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("body"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "body")));
+		if (operation.bodyContentType === "binary") requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("contentType"), ts.factory.createStringLiteral("application/octet-stream")));
+	}
+	requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("signal"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "signal")));
+	const requestCall = ts.factory.createCallExpression(ts.factory.createIdentifier(operation.requestFunction), operation.responseTypeExpr ? [createTypeNodeFromText(operation.responseTypeExpr)] : void 0, [parseExpression(operation.pathInvocationExpr), ts.factory.createObjectLiteralExpression(requestProperties, true)]);
+	return ts.factory.createFunctionDeclaration([createExportModifier()], void 0, ts.factory.createIdentifier(operation.funcName), void 0, [ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("options"), void 0, ts.factory.createTypeReferenceNode(operation.optionTypeName)), ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("requestOptions"), void 0, ts.factory.createTypeReferenceNode("RuntimeRequestOptions"), ts.factory.createObjectLiteralExpression())], createTypeNodeFromText(operation.returnTypeExpr), ts.factory.createBlock([ts.factory.createReturnStatement(requestCall)], true));
+}
+function createBuildSearchParamsFunction() {
+	return ts.factory.createFunctionDeclaration(void 0, void 0, ts.factory.createIdentifier("buildSearchParams"), void 0, [ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("query"), void 0, createTypeNodeFromText("Record<string, unknown> | undefined"))], createTypeNodeFromText("URLSearchParams | undefined"), ts.factory.createBlock([
+		ts.factory.createIfStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier("query"), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createIdentifier("undefined")), ts.factory.createReturnStatement(ts.factory.createIdentifier("undefined"))),
+		ts.factory.createVariableStatement(void 0, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier("entries"), void 0, void 0, parseExpression("Object.entries(query).filter(([, value]) => value != null)"))], ts.NodeFlags.Const)),
+		ts.factory.createIfStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("entries"), "length"), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createNumericLiteral("0")), ts.factory.createReturnStatement(ts.factory.createIdentifier("undefined"))),
+		ts.factory.createVariableStatement(void 0, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier("searchParams"), void 0, void 0, ts.factory.createNewExpression(ts.factory.createIdentifier("URLSearchParams"), void 0, []))], ts.NodeFlags.Const)),
+		ts.factory.createForOfStatement(void 0, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createArrayBindingPattern([ts.factory.createBindingElement(void 0, void 0, "key"), ts.factory.createBindingElement(void 0, void 0, "value")]))], ts.NodeFlags.Const), ts.factory.createIdentifier("entries"), ts.factory.createBlock([ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("searchParams"), "set"), void 0, [ts.factory.createIdentifier("key"), ts.factory.createCallExpression(ts.factory.createIdentifier("String"), void 0, [ts.factory.createIdentifier("value")])]))], true)),
+		ts.factory.createReturnStatement(ts.factory.createIdentifier("searchParams"))
+	], true));
+}
+function capitalize$1(value) {
+	if (value.length === 0) return value;
+	return `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+//#endregion
+//#region src/normalization.ts
+const HTTP_METHODS = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"patch"
+];
+function buildClientRenderModelFromOperations(operations, spec, requestFunctionNames = {
+	json: "requestJson",
+	void: "requestVoid"
+}) {
+	const context = buildNormalizationContext(spec);
+	const normalized = operations.map((entry) => normalizeOperation(entry, context, requestFunctionNames));
+	return {
+		operations: normalized,
+		needsSearchParamsHelper: normalized.some((operation) => operation.queryChannel.present),
+		typeAliases: collectTypeAliases(normalized)
+	};
+}
+function collectOperations(spec, pathPrefix = "/api/", stripPrefix = true) {
+	const apiPaths = Object.keys(spec.paths ?? {}).filter((path) => path.startsWith(pathPrefix)).sort();
+	if (apiPaths.length === 0) throw new Error(`No paths matching prefix "${pathPrefix}" found in openapi.json`);
+	const entries = [];
+	for (const apiPath of apiPaths) {
+		const pathItem = spec.paths?.[apiPath];
+		if (!pathItem) continue;
+		for (const method of HTTP_METHODS) {
+			const operation = pathItem[method];
+			if (!operation?.operationId) continue;
+			const strippedPath = stripPrefix ? apiPath.replace(pathPrefix, "") : apiPath;
+			entries.push({
+				apiPath,
+				funcName: makeFuncName(operation.operationId, method, apiPath, pathPrefix),
+				group: strippedPath.split("/")[0] ?? "misc",
+				method,
+				operation,
+				operationId: operation.operationId,
+				strippedPath
+			});
+		}
+	}
+	return entries;
+}
+function getEffectiveParametersByLocation(entry, location) {
+	return (entry.operation.parameters ?? []).filter((parameter) => getEffectiveParameterLocation(entry.apiPath, parameter) === location);
+}
+function warnOnParameterLocationMismatch(operations) {
+	for (const entry of operations) for (const parameter of entry.operation.parameters ?? []) {
+		const effectiveLocation = getEffectiveParameterLocation(entry.apiPath, parameter);
+		if (effectiveLocation === parameter.in) continue;
+		console.warn(`[openapi-codegen] normalized parameter "${parameter.name}" for "${entry.operationId}" from ${parameter.in} to ${effectiveLocation}.`);
+	}
+}
+function buildNormalizationContext(spec) {
+	const schemaAliasIndex = /* @__PURE__ */ new Map();
+	const schemaNames = /* @__PURE__ */ new Set();
+	for (const [name, schema] of Object.entries(spec.components?.schemas ?? {})) {
+		schemaNames.add(name);
+		const props = Object.keys(schema.properties ?? {}).sort().join(",");
+		if (!props) continue;
+		if (!schemaAliasIndex.has(props)) schemaAliasIndex.set(props, []);
+		schemaAliasIndex.get(props)?.push(name);
+	}
+	return {
+		schemaAliasIndex,
+		schemaNames,
+		usedTypeNames: new Set(schemaNames)
+	};
+}
+function getParametersByLocation(operation, location) {
+	return (operation.parameters ?? []).filter((parameter) => parameter.in === location);
+}
+function hasRequiredChannel(parameters) {
+	return parameters.some((parameter) => parameter.required);
+}
+function getSuccessResponseInfo(operation) {
+	const successResponses = Object.entries(operation.responses ?? {}).filter(([statusKey]) => isSuccessStatus(statusKey)).sort(([left], [right]) => Number(left) - Number(right));
+	if (successResponses.length === 0) throw new Error(`Operation "${operation.operationId ?? "unknown"}" has no 2xx success response`);
+	const withJson = successResponses.find(([, response]) => response.content?.["application/json"]);
+	if (withJson) return {
+		hasJsonBody: true,
+		statusKey: withJson[0]
+	};
+	return {
+		hasJsonBody: false,
+		statusKey: successResponses[0][0]
+	};
+}
+function isSuccessStatus(statusKey) {
+	const value = Number(statusKey);
+	return Number.isInteger(value) && value >= 200 && value < 300;
+}
+function formatStatusKey(statusKey) {
+	return Number.isInteger(Number(statusKey)) ? statusKey : `'${statusKey}'`;
+}
+function getBuilderAlias(funcName) {
+	return `build${capitalize(funcName)}Path`;
+}
+function getClientOptionTypeName(funcName) {
+	return `${capitalize(funcName)}Options`;
+}
+function makeFuncName(operationId, method, apiPath, pathPrefix = "/api/") {
+	const normalizedOperationId = toFunctionName(operationId);
+	if (normalizedOperationId.length > 0) return normalizedOperationId;
+	const segments = apiPath.replace(pathPrefix, "").split("/");
+	const result = [];
+	for (const segment of segments) {
+		if (segment.startsWith("{")) {
+			const resource = segment.slice(1, -1).replace(/_id$/, "");
+			if (result.length > 0) result[result.length - 1] = resource;
+			continue;
+		}
+		result.push(segment);
+	}
+	return `${method}${capitalize(result.map((segment, index) => {
+		const clean = segment.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+		return index === 0 ? clean : `${clean[0].toUpperCase()}${clean.slice(1)}`;
+	}).join(""))}`;
+}
+function toFunctionName(value) {
+	const segments = value.split(/[^a-zA-Z0-9]+/g).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+	if (segments.length === 0) return "";
+	const [firstSegment, ...restSegments] = segments;
+	const normalized = [firstSegment[0].toLowerCase() + firstSegment.slice(1), ...restSegments.map((segment) => capitalize(segment.toLowerCase()))].join("");
+	return /^[A-Za-z_$]/.test(normalized) ? normalized : `_${normalized}`;
+}
+function capitalize(value) {
+	if (value.length === 0) return value;
+	return `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+function getEffectiveParameterLocation(apiPath, parameter) {
+	if (parameter.in !== "path") return parameter.in;
+	return getTemplateParameterNames(apiPath).has(parameter.name) ? "path" : "query";
+}
+function getTemplateParameterNames(apiPath) {
+	const matches = apiPath.match(/\{(\w+)\}/g) ?? [];
+	return new Set(matches.map((match) => match.slice(1, -1)));
+}
+function resolveParameterTypeReference(entry, context, location) {
+	const effectiveParameters = getEffectiveParametersByLocation(entry, location);
+	if (effectiveParameters.length === 0) return null;
+	const schemaTypeRef = resolveAlias(context, effectiveParameters.map((parameter) => parameter.name), entry.operation.tags?.[0]);
+	if (schemaTypeRef) return schemaTypeRef;
+	const rawParameters = getParametersByLocation(entry.operation, location);
+	const typeName = allocateOperationTypeName(context, entry.funcName, location === "path" ? "Path" : "Query");
+	if (hasSameParameterNames(rawParameters, effectiveParameters)) return {
+		aliasDefinitionExpr: `operations['${entry.operationId}']['parameters']['${location}']`,
+		sourceExpr: `operations['${entry.operationId}']['parameters']['${location}']`,
+		typeName
+	};
+	return {
+		aliasDefinitionExpr: renderInlineParameterObject(effectiveParameters),
+		sourceExpr: renderInlineParameterObject(effectiveParameters),
+		typeName
+	};
+}
+function normalizeOperation(entry, context, requestFunctionNames) {
+	const successResponse = getSuccessResponseInfo(entry.operation);
+	const builderAlias = getBuilderAlias(entry.funcName);
+	const pathChannel = normalizeParameterChannel(entry, context, "path");
+	const queryChannel = normalizeParameterChannel(entry, context, "query");
+	const bodyResolution = normalizeBodyChannel(entry, context);
+	const responseTypeRef = resolveResponseTypeReference(entry, context, successResponse);
+	return {
+		bodyChannel: bodyResolution.channel,
+		bodyContentType: bodyResolution.contentType,
+		builderAlias,
+		entry,
+		optionTypeName: getClientOptionTypeName(entry.funcName),
+		pathChannel,
+		pathInvocationExpr: pathChannel.present ? `${builderAlias}(options.path)` : `${builderAlias}()`,
+		queryChannel,
+		requestFunction: responseTypeRef ? requestFunctionNames.json : requestFunctionNames.void,
+		responseTypeRef,
+		returnTypeExpr: responseTypeRef ? `Promise<${responseTypeRef.typeName}>` : "Promise<void>"
+	};
+}
+function normalizeParameterChannel(entry, context, location) {
+	const parameters = getEffectiveParametersByLocation(entry, location);
+	if (parameters.length === 0) return {
+		present: false,
+		required: false,
+		typeRef: null
+	};
+	return {
+		present: true,
+		required: hasRequiredChannel(parameters),
+		typeRef: resolveParameterTypeReference(entry, context, location)
+	};
+}
+function normalizeBodyChannel(entry, context) {
+	const requestBody = entry.operation.requestBody;
+	if (!requestBody) return {
+		channel: {
+			present: false,
+			required: false,
+			typeRef: null
+		},
+		contentType: null
+	};
+	const content = requestBody.content ?? {};
+	const jsonBody = content["application/json"];
+	if (jsonBody) return {
+		channel: createRequestBodyChannel(entry, context, jsonBody, "json"),
+		contentType: "json"
+	};
+	const binaryBody = content["application/octet-stream"];
+	if (binaryBody) return {
+		channel: createRequestBodyChannel(entry, context, binaryBody, "binary"),
+		contentType: "binary"
+	};
+	const multipartBody = content["multipart/form-data"];
+	if (multipartBody) return {
+		channel: createRequestBodyChannel(entry, context, multipartBody, "formData"),
+		contentType: "formData"
+	};
+	throw new Error(`Operation "${entry.operationId ?? "unknown"}" has a requestBody but no supported content type`);
+}
+function createRequestBodyChannel(entry, context, body, kind) {
+	const typeRef = resolveRequestBodyTypeReference(entry, context, body, kind);
+	if (!typeRef) return {
+		present: false,
+		required: false,
+		typeRef: null
+	};
+	return {
+		present: true,
+		required: entry.operation.requestBody?.required !== false,
+		typeRef
+	};
+}
+function resolveRequestBodyTypeReference(entry, context, body, kind) {
+	if (kind === "formData") return {
+		aliasDefinitionExpr: "FormData",
+		sourceExpr: "FormData",
+		typeName: allocateOperationTypeName(context, entry.funcName, "Request")
+	};
+	if (kind === "binary") return {
+		aliasDefinitionExpr: "Blob | File | ArrayBuffer | string",
+		sourceExpr: "Blob | File | ArrayBuffer | string",
+		typeName: allocateOperationTypeName(context, entry.funcName, "Request")
+	};
+	const schemaTypeRef = resolveSchemaTypeReference(context, body.schema);
+	if (schemaTypeRef) return schemaTypeRef;
+	return {
+		aliasDefinitionExpr: `operations['${entry.operationId}']['requestBody']['content']['application/json']`,
+		sourceExpr: `operations['${entry.operationId}']['requestBody']['content']['application/json']`,
+		typeName: allocateOperationTypeName(context, entry.funcName, "Request")
+	};
+}
+function resolveResponseTypeReference(entry, context, successResponse) {
+	if (!successResponse.hasJsonBody) return null;
+	const jsonContent = (entry.operation.responses?.[successResponse.statusKey])?.content?.["application/json"];
+	const schemaTypeRef = resolveSchemaTypeReference(context, jsonContent?.schema);
+	if (schemaTypeRef) return schemaTypeRef;
+	return {
+		aliasDefinitionExpr: `operations['${entry.operationId}']['responses'][${formatStatusKey(successResponse.statusKey)}]['content']['application/json']`,
+		sourceExpr: `operations['${entry.operationId}']['responses'][${formatStatusKey(successResponse.statusKey)}]['content']['application/json']`,
+		typeName: allocateOperationTypeName(context, entry.funcName, "Response")
+	};
+}
+function hasSameParameterNames(left, right) {
+	if (left.length !== right.length) return false;
+	const leftNames = left.map((parameter) => parameter.name).sort();
+	const rightNames = right.map((parameter) => parameter.name).sort();
+	return leftNames.every((name, index) => name === rightNames[index]);
+}
+function resolveAlias(context, parameterNames, tag) {
+	const key = [...parameterNames].sort().join(",");
+	const candidates = context.schemaAliasIndex.get(key);
+	if (!candidates || candidates.length === 0) return;
+	if (candidates.length === 1) return createSchemaTypeReference(candidates[0]);
+	if (tag) {
+		const singularTag = tag.replace(/s$/, "");
+		const prefix = `${singularTag[0]?.toUpperCase() ?? ""}${singularTag.slice(1)}`;
+		const match = candidates.find((candidate) => candidate.startsWith(prefix));
+		if (match) return createSchemaTypeReference(match);
+	}
+	return createSchemaTypeReference(candidates[0]);
+}
+function resolveSchemaTypeReference(context, schema) {
+	const ref = readSchemaRef(schema);
+	if (!ref) return;
+	const schemaName = ref.split("/").pop();
+	if (!schemaName || !context.schemaNames.has(schemaName)) return;
+	return createSchemaTypeReference(schemaName);
+}
+function createSchemaTypeReference(schemaName) {
+	return {
+		aliasDefinitionExpr: null,
+		sourceExpr: `components['schemas']['${schemaName}']`,
+		typeName: schemaName
+	};
+}
+function readSchemaRef(schema) {
+	if (!schema || typeof schema !== "object") return;
+	const maybeRef = schema.$ref;
+	return typeof maybeRef === "string" ? maybeRef : void 0;
+}
+function renderInlineParameterObject(parameters) {
+	return `{ ${parameters.map((parameter) => {
+		const optionalMarker = parameter.required ? "" : "?";
+		return `${parameter.name}${optionalMarker}: ${renderPrimitiveSchemaType(parameter.schema)}`;
+	}).join("; ")} }`;
+}
+function renderPrimitiveSchemaType(schema) {
+	const type = schema?.type;
+	if (!type) return "unknown";
+	if (Array.isArray(type)) return type.map((memberType) => mapPrimitiveType(memberType)).join(" | ");
+	return mapPrimitiveType(type);
+}
+function allocateOperationTypeName(context, funcName, suffix) {
+	const preferredName = `${capitalize(funcName)}${suffix}`;
+	if (!context.usedTypeNames.has(preferredName)) {
+		context.usedTypeNames.add(preferredName);
+		return preferredName;
+	}
+	let counter = 2;
+	let candidate = `${preferredName}_${counter}`;
+	while (context.usedTypeNames.has(candidate)) {
+		counter += 1;
+		candidate = `${preferredName}_${counter}`;
+	}
+	context.usedTypeNames.add(candidate);
+	return candidate;
+}
+function collectTypeAliases(operations) {
+	const aliases = /* @__PURE__ */ new Map();
+	for (const operation of operations) {
+		collectTypeAlias(aliases, operation.pathChannel.typeRef);
+		collectTypeAlias(aliases, operation.queryChannel.typeRef);
+		collectTypeAlias(aliases, operation.bodyChannel.typeRef);
+		collectTypeAlias(aliases, operation.responseTypeRef);
+	}
+	return [...aliases.entries()].map(([typeName, definitionExpr]) => ({
+		definitionExpr,
+		typeName
+	})).sort((left, right) => left.typeName.localeCompare(right.typeName));
+}
+function collectTypeAlias(aliases, typeRef) {
+	if (!typeRef || typeRef.aliasDefinitionExpr == null) return;
+	const existing = aliases.get(typeRef.typeName);
+	if (existing && existing !== typeRef.aliasDefinitionExpr) throw new Error(`Conflicting generated type alias "${typeRef.typeName}" with incompatible definitions.`);
+	aliases.set(typeRef.typeName, typeRef.aliasDefinitionExpr);
+}
+function mapPrimitiveType(type) {
+	switch (type) {
+		case "integer":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		case "string": return "string";
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region src/plugin.ts
+const HTTP_CLIENT_DEFAULTS = {
+	module: "#/integrations/http",
+	jsonFunction: "requestJson",
+	voidFunction: "requestVoid",
+	requestOptionsType: "ApiRequestOptions",
+	omitKeys: [
+		"json",
+		"method",
+		"searchParams",
+		"signal"
+	]
+};
+function resolveHttpClientConfig(config) {
+	return {
+		...HTTP_CLIENT_DEFAULTS,
+		...config
+	};
+}
+const GENERATED_HEADER = ["// This file is auto-generated by vite-plugin-openapi-codegen.", "// Do not edit manually. Changes will be overwritten on next build."];
+async function generateApiTypes(source, outputDir, useTypeAliases) {
+	const { default: openapiTS, astToString } = await import("openapi-typescript");
+	const contents = astToString(await openapiTS(source, useTypeAliases ? {
+		rootTypes: true,
+		rootTypesKeepCasing: true,
+		rootTypesNoSchemaPrefix: true
+	} : void 0));
+	writeFileSync(resolve(outputDir, "api-types.d.ts"), `${GENERATED_HEADER.join("\n")}\n\n${contents}`);
+}
+function createApiEntries(normalizedOps, useTypeAliases) {
+	return normalizedOps.map((op) => ({
+		funcName: op.entry.funcName,
+		group: op.entry.group,
+		bodyContentType: op.bodyContentType,
+		pathTypeExpr: op.pathChannel.typeRef == null ? null : useTypeAliases ? op.pathChannel.typeRef.typeName : op.pathChannel.typeRef.sourceExpr,
+		strippedPath: op.entry.strippedPath
+	}));
+}
+function createClientRenderModel(model, useTypeAliases) {
+	const resolveTypeExpr = (typeRef) => typeRef == null ? null : useTypeAliases ? typeRef.typeName : typeRef.sourceExpr;
+	const resolveReturnTypeExpr = (operation) => {
+		const responseTypeExpr = resolveTypeExpr(operation.responseTypeRef);
+		return responseTypeExpr ? `Promise<${responseTypeExpr}>` : "Promise<void>";
+	};
+	return {
+		needsSearchParamsHelper: model.needsSearchParamsHelper,
+		operations: model.operations.map((operation) => ({
+			bodyChannel: resolveChannel(operation.bodyChannel, useTypeAliases),
+			bodyContentType: operation.bodyContentType,
+			builderAlias: operation.builderAlias,
+			funcName: operation.entry.funcName,
+			group: operation.entry.group,
+			methodUpper: operation.entry.method.toUpperCase(),
+			optionTypeName: operation.optionTypeName,
+			pathChannel: resolveChannel(operation.pathChannel, useTypeAliases),
+			pathInvocationExpr: operation.pathInvocationExpr,
+			queryChannel: resolveChannel(operation.queryChannel, useTypeAliases),
+			requestFunction: operation.requestFunction,
+			responseTypeExpr: resolveTypeExpr(operation.responseTypeRef),
+			returnTypeExpr: resolveReturnTypeExpr(operation)
+		}))
+	};
+}
+function resolveChannel(channel, useTypeAliases) {
+	if (!channel.typeRef) return channel;
+	return {
+		...channel,
+		typeRef: {
+			...channel.typeRef,
+			sourceExpr: useTypeAliases ? channel.typeRef.typeName : channel.typeRef.sourceExpr
+		}
+	};
+}
+function renderGeneratedArtifacts(spec, options, preCollectedOperations) {
+	const pathPrefix = options.pathPrefix ?? "/api/";
+	const stripPrefix = options.stripPrefix ?? true;
+	const httpClient = resolveHttpClientConfig(options.httpClient);
+	const useTypeAliases = options.typeAliases ?? false;
+	const clientModel = buildClientRenderModelFromOperations(preCollectedOperations ?? collectOperations(spec, pathPrefix, stripPrefix), spec, {
+		json: httpClient.jsonFunction,
+		void: httpClient.voidFunction
+	});
+	if (clientModel.operations.length === 0) throw new Error(`No paths matching prefix "${pathPrefix}" found in openapi.json`);
+	return {
+		api: renderApiSource(createApiEntries(clientModel.operations, useTypeAliases), GENERATED_HEADER),
+		client: renderClientSource(createClientRenderModel(clientModel, useTypeAliases), GENERATED_HEADER, httpClient),
+		...useTypeAliases && clientModel.typeAliases.length > 0 ? { apiTypes: renderOperationTypeAliases(clientModel.typeAliases) } : {}
+	};
+}
+async function loadOpenAPIInput(root, input) {
+	if (isHttpUrl(input)) {
+		const sourceText = await fetchRemoteOpenAPIInput(input);
+		return {
+			apiTypesSource: sourceText,
+			spec: parseOpenAPISpec(sourceText, input)
+		};
+	}
+	const inputPath = resolve(root, input);
+	const sourceText = readFileSync(inputPath, "utf-8");
+	return {
+		apiTypesSource: pathToFileURL(inputPath),
+		spec: parseOpenAPISpec(sourceText, inputPath)
+	};
+}
+function isHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+async function fetchRemoteOpenAPIInput(input) {
+	const response = await fetch(input);
+	if (!response.ok) throw new Error(`[openapi-codegen] Failed to fetch OpenAPI document from ${input}: ${response.status} ${response.statusText}`);
+	return response.text();
+}
+function parseOpenAPISpec(sourceText, inputLabel) {
+	const parsed = parse(sourceText);
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`[openapi-codegen] Expected OpenAPI document object from ${inputLabel}`);
+	return parsed;
+}
+async function generateOpenAPIArtifacts(root, options) {
+	const outputDir = resolve(root, options.output);
+	mkdirSync(outputDir, { recursive: true });
+	const { apiTypesSource, spec } = await loadOpenAPIInput(root, options.input);
+	const operations = collectOperations(spec, options.pathPrefix ?? "/api/", options.stripPrefix ?? true);
+	const artifacts = renderGeneratedArtifacts(spec, options, operations);
+	warnOnParameterLocationMismatch(operations);
+	await generateApiTypes(apiTypesSource, outputDir, options.typeAliases ?? false);
+	if (artifacts.apiTypes) writeFileSync(resolve(outputDir, "api-types.d.ts"), artifacts.apiTypes, { flag: "a" });
+	writeFileSync(resolve(outputDir, "api.ts"), artifacts.api);
+	writeFileSync(resolve(outputDir, "client.ts"), artifacts.client);
+}
+//#endregion
+//#region src/cli.ts
+const CONFIG_FILE_NAMES = [
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.cjs",
+	"vite.config.cts"
+];
+async function main(argv) {
+	const flags = parseArgs(argv);
+	if (flags.help) {
+		printHelp();
+		return;
+	}
+	const root = resolve(process.cwd(), flags.root ?? ".");
+	const options = mergeOptions(await loadOptionsFromViteConfig(root, flags.config), createOptionsFromFlags(flags));
+	if (!options.input || !options.output) throw new Error("[openapi-codegen] Missing required options. Provide --input and --output or configure openapiCodegen() in vite.config.");
+	await generateOpenAPIArtifacts(root, options);
+	console.log(`[openapi-codegen] generated files in ${resolve(root, options.output)}`);
+}
+function parseArgs(argv) {
+	const flags = {};
+	for (let index = 0; index < argv.length; index++) {
+		const arg = argv[index];
+		const [name, inlineValue] = arg.split("=", 2);
+		switch (name) {
+			case "--config":
+				flags.config = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--help":
+			case "-h":
+				flags.help = true;
+				break;
+			case "--http-client-json-function":
+				flags.httpClientJsonFunction = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--http-client-module":
+				flags.httpClientModule = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--http-client-omit-keys":
+				flags.httpClientOmitKeys = parseCommaList(readValue(argv, ++index, inlineValue, name));
+				break;
+			case "--http-client-request-options-type":
+				flags.httpClientRequestOptionsType = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--http-client-void-function":
+				flags.httpClientVoidFunction = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--input":
+				flags.input = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--output":
+				flags.output = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--path-prefix":
+				flags.pathPrefix = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--root":
+				flags.root = readValue(argv, ++index, inlineValue, name);
+				break;
+			case "--strip-prefix":
+				flags.stripPrefix = parseBoolean(readValue(argv, ++index, inlineValue, name), name);
+				break;
+			case "--type-aliases":
+				flags.typeAliases = true;
+				break;
+			case "--no-strip-prefix":
+				flags.stripPrefix = false;
+				break;
+			case "--no-type-aliases":
+				flags.typeAliases = false;
+				break;
+			default: throw new Error(`[openapi-codegen] Unknown option: ${arg}`);
+		}
+		if (inlineValue !== void 0) index--;
+	}
+	return flags;
+}
+function readValue(argv, index, inlineValue, name) {
+	if (inlineValue !== void 0) return inlineValue;
+	const value = argv[index];
+	if (!value || value.startsWith("--")) throw new Error(`[openapi-codegen] Missing value for ${name}`);
+	return value;
+}
+function parseBoolean(value, name) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	throw new Error(`[openapi-codegen] Expected ${name} to be true or false`);
+}
+function parseCommaList(value) {
+	if (value.length === 0) return [];
+	return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+async function loadOptionsFromViteConfig(root, configPath) {
+	const resolvedConfigPath = resolveViteConfigPath(root, configPath);
+	if (!resolvedConfigPath) return {};
+	return extractOpenAPICodegenOptions((await loadConfigFromFile({
+		command: "serve",
+		mode: "development"
+	}, resolvedConfigPath, root, "silent"))?.config.plugins) ?? {};
+}
+function resolveViteConfigPath(root, configPath) {
+	if (configPath) {
+		const resolved = resolve(root, configPath);
+		if (!existsSync(resolved)) throw new Error(`[openapi-codegen] Vite config not found: ${resolved}`);
+		return resolved;
+	}
+	return CONFIG_FILE_NAMES.map((fileName) => resolve(root, fileName)).find((filePath) => existsSync(filePath));
+}
+function extractOpenAPICodegenOptions(plugins) {
+	return flattenPlugins(plugins).find(isOpenAPICodegenPlugin)?.api?.options;
+}
+function flattenPlugins(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((plugin) => {
+		if (Array.isArray(plugin)) return flattenPlugins(plugin);
+		if (!plugin || typeof plugin !== "object") return [];
+		return [plugin];
+	});
+}
+function isOpenAPICodegenPlugin(plugin) {
+	return plugin.name === "openapi-codegen" && Boolean(plugin.api?.options);
+}
+function createOptionsFromFlags(flags) {
+	const httpClient = createHttpClientConfigFromFlags(flags);
+	return {
+		...flags.input ? { input: flags.input } : {},
+		...flags.output ? { output: flags.output } : {},
+		...flags.pathPrefix ? { pathPrefix: flags.pathPrefix } : {},
+		...flags.stripPrefix !== void 0 ? { stripPrefix: flags.stripPrefix } : {},
+		...flags.typeAliases !== void 0 ? { typeAliases: flags.typeAliases } : {},
+		...httpClient ? { httpClient } : {}
+	};
+}
+function createHttpClientConfigFromFlags(flags) {
+	const httpClient = {
+		...flags.httpClientModule ? { module: flags.httpClientModule } : {},
+		...flags.httpClientJsonFunction ? { jsonFunction: flags.httpClientJsonFunction } : {},
+		...flags.httpClientVoidFunction ? { voidFunction: flags.httpClientVoidFunction } : {},
+		...flags.httpClientRequestOptionsType ? { requestOptionsType: flags.httpClientRequestOptionsType } : {},
+		...flags.httpClientOmitKeys ? { omitKeys: flags.httpClientOmitKeys } : {}
+	};
+	return Object.keys(httpClient).length > 0 ? httpClient : void 0;
+}
+function mergeOptions(configOptions, explicitOptions) {
+	return {
+		...configOptions,
+		...explicitOptions,
+		httpClient: configOptions.httpClient || explicitOptions.httpClient ? {
+			...configOptions.httpClient,
+			...explicitOptions.httpClient
+		} : void 0
+	};
+}
+function printHelp() {
+	console.log(`Usage: vg [options]
+
+Generate OpenAPI client files once.
+
+Options:
+  --input <path-or-url>                    OpenAPI JSON/YAML input
+  --output <dir>                           Generated output directory
+  --root <dir>                             Project root, defaults to cwd
+  --config <file>                          Vite config path, defaults to vite.config.*
+  --path-prefix <prefix>                   Path prefix filter
+  --strip-prefix <true|false>              Strip path prefix from generated paths
+  --no-strip-prefix                        Disable path prefix stripping
+  --type-aliases                           Enable top-level generated type aliases
+  --no-type-aliases                        Disable top-level generated type aliases
+  --http-client-module <module>            Runtime HTTP module import path
+  --http-client-json-function <name>       JSON request function name
+  --http-client-void-function <name>       Void request function name
+  --http-client-request-options-type <name> Request options type name
+  --http-client-omit-keys <keys>           Comma-separated keys omitted from request options
+  -h, --help                               Show help
+`);
+}
+main(process.argv.slice(2)).catch((error) => {
+	console.error(error instanceof Error ? error.message : error);
+	process.exitCode = 1;
+});
+//#endregion
+export {};

package/dist/index.mjs

@@ -144,7 +144,11 @@ function createClientChannelField(key, channel) {
 function createClientFunctionDeclaration(operation) {
 	const requestProperties = [ts.factory.createSpreadAssignment(ts.factory.createIdentifier("requestOptions")), ts.factory.createPropertyAssignment(ts.factory.createIdentifier("method"), ts.factory.createStringLiteral(operation.methodUpper))];
 	if (operation.queryChannel.present) requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("searchParams"), ts.factory.createCallExpression(ts.factory.createIdentifier("buildSearchParams"), void 0, [ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "query")])));
-	if (operation.bodyChannel.present) requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("json"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "body")));
+	if (operation.bodyChannel.present) {
+		if (operation.bodyContentType === "json") requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("json"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "body")));
+		else requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("body"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "body")));
+		if (operation.bodyContentType === "binary") requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("contentType"), ts.factory.createStringLiteral("application/octet-stream")));
+	}
 	requestProperties.push(ts.factory.createPropertyAssignment(ts.factory.createIdentifier("signal"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("options"), "signal")));
 	const requestCall = ts.factory.createCallExpression(ts.factory.createIdentifier(operation.requestFunction), operation.responseTypeExpr ? [createTypeNodeFromText(operation.responseTypeExpr)] : void 0, [parseExpression(operation.pathInvocationExpr), ts.factory.createObjectLiteralExpression(requestProperties, true)]);
 	return ts.factory.createFunctionDeclaration([createExportModifier()], void 0, ts.factory.createIdentifier(operation.funcName), void 0, [ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("options"), void 0, ts.factory.createTypeReferenceNode(operation.optionTypeName)), ts.factory.createParameterDeclaration(void 0, void 0, ts.factory.createIdentifier("requestOptions"), void 0, ts.factory.createTypeReferenceNode("RuntimeRequestOptions"), ts.factory.createObjectLiteralExpression())], createTypeNodeFromText(operation.returnTypeExpr), ts.factory.createBlock([ts.factory.createReturnStatement(requestCall)], true));
@@ -240,13 +244,6 @@ function getParametersByLocation(operation, location) {
 function hasRequiredChannel(parameters) {
 	return parameters.some((parameter) => parameter.required);
 }
-function getJsonRequestBody(operation) {
-	const requestBody = operation.requestBody;
-	if (!requestBody) return void 0;
-	const jsonBody = requestBody.content?.["application/json"];
-	if (!jsonBody) throw new Error(`Operation "${operation.operationId ?? "unknown"}" has a requestBody but no application/json content`);
-	return jsonBody;
-}
 function getSuccessResponseInfo(operation) {
 	const successResponses = Object.entries(operation.responses ?? {}).filter(([statusKey]) => isSuccessStatus(statusKey)).sort(([left], [right]) => Number(left) - Number(right));
 	if (successResponses.length === 0) throw new Error(`Operation "${operation.operationId ?? "unknown"}" has no 2xx success response`);
@@ -333,10 +330,11 @@ function normalizeOperation(entry, context, requestFunctionNames) {
 	const builderAlias = getBuilderAlias(entry.funcName);
 	const pathChannel = normalizeParameterChannel(entry, context, "path");
 	const queryChannel = normalizeParameterChannel(entry, context, "query");
-	const bodyChannel = normalizeBodyChannel(entry, context);
+	const bodyResolution = normalizeBodyChannel(entry, context);
 	const responseTypeRef = resolveResponseTypeReference(entry, context, successResponse);
 	return {
-		bodyChannel,
+		bodyChannel: bodyResolution.channel,
+		bodyContentType: bodyResolution.contentType,
 		builderAlias,
 		entry,
 		optionTypeName: getClientOptionTypeName(entry.funcName),
@@ -362,7 +360,35 @@ function normalizeParameterChannel(entry, context, location) {
 	};
 }
 function normalizeBodyChannel(entry, context) {
-	const typeRef = resolveRequestBodyTypeReference(entry, context);
+	const requestBody = entry.operation.requestBody;
+	if (!requestBody) return {
+		channel: {
+			present: false,
+			required: false,
+			typeRef: null
+		},
+		contentType: null
+	};
+	const content = requestBody.content ?? {};
+	const jsonBody = content["application/json"];
+	if (jsonBody) return {
+		channel: createRequestBodyChannel(entry, context, jsonBody, "json"),
+		contentType: "json"
+	};
+	const binaryBody = content["application/octet-stream"];
+	if (binaryBody) return {
+		channel: createRequestBodyChannel(entry, context, binaryBody, "binary"),
+		contentType: "binary"
+	};
+	const multipartBody = content["multipart/form-data"];
+	if (multipartBody) return {
+		channel: createRequestBodyChannel(entry, context, multipartBody, "formData"),
+		contentType: "formData"
+	};
+	throw new Error(`Operation "${entry.operationId ?? "unknown"}" has a requestBody but no supported content type`);
+}
+function createRequestBodyChannel(entry, context, body, kind) {
+	const typeRef = resolveRequestBodyTypeReference(entry, context, body, kind);
 	if (!typeRef) return {
 		present: false,
 		required: false,
@@ -374,10 +400,18 @@ function normalizeBodyChannel(entry, context) {
 		typeRef
 	};
 }
-function resolveRequestBodyTypeReference(entry, context) {
-	const jsonBody = getJsonRequestBody(entry.operation);
-	if (!jsonBody) return null;
-	const schemaTypeRef = resolveSchemaTypeReference(context, jsonBody.schema);
+function resolveRequestBodyTypeReference(entry, context, body, kind) {
+	if (kind === "formData") return {
+		aliasDefinitionExpr: "FormData",
+		sourceExpr: "FormData",
+		typeName: allocateOperationTypeName(context, entry.funcName, "Request")
+	};
+	if (kind === "binary") return {
+		aliasDefinitionExpr: "Blob | File | ArrayBuffer | string",
+		sourceExpr: "Blob | File | ArrayBuffer | string",
+		typeName: allocateOperationTypeName(context, entry.funcName, "Request")
+	};
+	const schemaTypeRef = resolveSchemaTypeReference(context, body.schema);
 	if (schemaTypeRef) return schemaTypeRef;
 	return {
 		aliasDefinitionExpr: `operations['${entry.operationId}']['requestBody']['content']['application/json']`,
@@ -524,6 +558,7 @@ function createApiEntries(normalizedOps, useTypeAliases) {
 	return normalizedOps.map((op) => ({
 		funcName: op.entry.funcName,
 		group: op.entry.group,
+		bodyContentType: op.bodyContentType,
 		pathTypeExpr: op.pathChannel.typeRef == null ? null : useTypeAliases ? op.pathChannel.typeRef.typeName : op.pathChannel.typeRef.sourceExpr,
 		strippedPath: op.entry.strippedPath
 	}));
@@ -538,6 +573,7 @@ function createClientRenderModel(model, useTypeAliases) {
 		needsSearchParamsHelper: model.needsSearchParamsHelper,
 		operations: model.operations.map((operation) => ({
 			bodyChannel: resolveChannel(operation.bodyChannel, useTypeAliases),
+			bodyContentType: operation.bodyContentType,
 			builderAlias: operation.builderAlias,
 			funcName: operation.entry.funcName,
 			group: operation.entry.group,
@@ -611,7 +647,7 @@ function parseOpenAPISpec(sourceText, inputLabel) {
 	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`[openapi-codegen] Expected OpenAPI document object from ${inputLabel}`);
 	return parsed;
 }
-async function generate(root, options) {
+async function generateOpenAPIArtifacts(root, options) {
 	const outputDir = resolve(root, options.output);
 	mkdirSync(outputDir, { recursive: true });
 	const { apiTypesSource, spec } = await loadOpenAPIInput(root, options.input);
@@ -629,6 +665,7 @@ function openapiCodegen(options) {
 	return {
 		name: "openapi-codegen",
 		enforce: "pre",
+		api: { options },
 		configResolved(config) {
 			root = config.root;
 			command = config.command;
@@ -639,24 +676,20 @@ function openapiCodegen(options) {
 				return;
 			}
 		},
-		configureServer(server) {
+		async handleHotUpdate(ctx) {
 			if (isHttpUrl(options.input)) return;
 			const inputPath = resolve(root, options.input);
-			server.watcher.add(inputPath);
-			server.watcher.on("change", async (path) => {
-				if (path === inputPath) {
-					console.log("[openapi-codegen] openapi.json changed, regenerating...");
-					runDevelopmentGeneration(root, options, { onSuccess: () => {
-						console.log("[openapi-codegen] regeneration complete.");
-					} });
-				}
-			});
+			if (resolve(ctx.file) !== inputPath) return;
+			console.log("[openapi-codegen] openapi.json changed, regenerating...");
+			await runDevelopmentGeneration(root, options, { onSuccess: () => {
+				console.log("[openapi-codegen] regeneration complete.");
+			} });
 		}
 	};
 }
 async function runDevelopmentGeneration(root, options, handlers) {
 	try {
-		await generate(root, options);
+		await generateOpenAPIArtifacts(root, options);
 		handlers?.onSuccess?.();
 	} catch (error) {
 		console.error("[openapi-codegen] generation failed during dev mode.", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-openapi-codegen",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Vite plugin that generates typed API clients and route builders from OpenAPI specs",
   "keywords": [
     "api-client",
@@ -22,6 +22,9 @@
     "type": "git",
     "url": "git+https://github.com/GGGLHHH/vite-plugin-openapi-codegen.git"
   },
+  "bin": {
+    "vg": "./dist/cli.mjs"
+  },
   "files": [
     "dist"
   ],
@@ -30,6 +33,7 @@
   "types": "./dist/index.d.mts",
   "exports": {
     ".": "./dist/index.mjs",
+    "./cli": "./dist/cli.mjs",
     "./package.json": "./package.json"
   },
   "publishConfig": {