@povio/openapi-codegen-cli 2.0.8-rc.23 → 2.0.8-rc.25

package/README.md

@@ -242,12 +242,17 @@ export default defineConfig({
       output: "./src/data",
       inlineEndpoints: true,
       incremental: true,
+      formatGeneratedFile: async ({ fileName, content }) => {
+        void fileName;
+        return content;
+      },
     }),
   ],
 });
 ```
 
 The plugin runs on both `vite serve` and `vite build`, and watches local OpenAPI files in dev mode.
+If you provide `formatGeneratedFile`, the plugin formats each generated file in memory before comparing and writing it, which helps avoid unnecessary HMR when the formatted output is unchanged.
 
 ### Enums
 

package/dist/{config-BHkVxL6S.d.mts → config-HbwoMgWr.d.mts}

@@ -1,4 +1,4 @@
-import { t as GenerateOptions } from "./options-BNqkO_OS.mjs";
+import { t as GenerateOptions } from "./options-PQDrYdAn.mjs";
 
 //#region src/generators/types/config.d.ts
 type OpenAPICodegenConfig = Partial<GenerateOptions>;

package/dist/{generate.runner-DKpRoYsX.mjs → generate.runner-C7QVcw6n.mjs}

@@ -1,4 +1,4 @@
-import { a as deepMerge, p as DEFAULT_GENERATE_OPTIONS, r as writeGenerateFileData, t as generateCodeFromOpenAPIDoc, x as Profiler } from "./generateCodeFromOpenAPIDoc-vrPucfhY.mjs";
+import { a as deepMerge, p as DEFAULT_GENERATE_OPTIONS, r as writeGenerateFileData, t as generateCodeFromOpenAPIDoc, x as Profiler } from "./generateCodeFromOpenAPIDoc-C7btBlMx.mjs";
 import fs from "fs";
 import path from "path";
 import SwaggerParser from "@apidevtools/swagger-parser";
@@ -17,7 +17,7 @@ function resolveConfig({ fileConfig = {}, params: { excludeTags, inlineEndpoints
 //#endregion
 //#region src/generators/run/generate.runner.ts
 const CACHE_FILE_NAME = ".openapi-codegen-cache.json";
-async function runGenerate({ fileConfig, params, profiler = new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1") }) {
+async function runGenerate({ fileConfig, params, formatGeneratedFile, profiler = new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1") }) {
 	const config = profiler.runSync("config.resolve", () => resolveConfig({
 		fileConfig,
 		params: params ?? {}
@@ -38,7 +38,9 @@ async function runGenerate({ fileConfig, params, profiler = new Profiler(process
 		};
 	}
 	const filesData = profiler.runSync("generate.total", () => generateCodeFromOpenAPIDoc(openApiDoc, config, profiler));
-	profiler.runSync("files.write", () => writeGenerateFileData(filesData));
+	await profiler.runAsync("files.write", async () => {
+		await writeGenerateFileData(filesData, { formatGeneratedFile });
+	});
 	const stats = getGenerateStats(filesData, config);
 	if (config.incremental) writeCache(cacheFilePath, {
 		openApiHash,

package/dist/{generateCodeFromOpenAPIDoc-vrPucfhY.mjs → generateCodeFromOpenAPIDoc-C7btBlMx.mjs}

@@ -3044,19 +3044,31 @@ function getTagElement(tag, data) {
 function getOutputFileName({ output, fileName }) {
 	return `${output}/${fileName}`;
 }
+function hashString(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i += 1) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16);
+}
 function writeFileWithDirSync(file, data) {
 	const dir = path.dirname(file);
 	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 	if (fs.existsSync(file)) {
-		if (fs.readFileSync(file, "utf-8") === data) return;
+		const existingData = fs.readFileSync(file, "utf-8");
+		if (hashString(existingData) === hashString(data) && existingData === data) return;
 	}
 	fs.writeFileSync(file, data, "utf-8");
 }
-function writeFileSync$1({ fileName, content }) {
-	writeFileWithDirSync(fileName, content);
+async function writeFile({ fileName, content }, options) {
+	writeFileWithDirSync(fileName, options?.formatGeneratedFile ? await options.formatGeneratedFile({
+		fileName,
+		content
+	}) : content);
 }
-function writeGenerateFileData(filesData) {
-	filesData.forEach(writeFileSync$1);
+async function writeGenerateFileData(filesData, options) {
+	for (const file of filesData) await writeFile(file, options);
 }
 
 //#endregion
@@ -3206,42 +3218,55 @@ function getBuilderConfigs({ data, tag, resolver }) {
 		if (createEndpoint) {
 			importedEndpoints.push(createEndpoint);
 			const body = getEndpointBody$1(createEndpoint);
-			if (body) importedZodSchemas.push(body.zodSchema);
-			config.create = {
-				acl: getAclConfig(createEndpoint, resolver.options),
-				mutation: getImportedQueryName(createEndpoint, resolver.options),
-				inputDefs: getInputsConfig(resolver, body)
-			};
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.create = {
+					acl: getAclConfig(createEndpoint, resolver.options),
+					schema: getImportedZodSchemaName(resolver, body.zodSchema),
+					mutation: createEndpoint,
+					inputDefs: getInputsConfig(resolver, body)
+				};
+			}
 		}
 		const updateEndpoint = extendedEndpoints.find((endpoint) => isUpdateEndpoint(endpoint, readAllEndpoint));
 		if (updateEndpoint) {
 			importedEndpoints.push(updateEndpoint);
 			const body = getEndpointBody$1(updateEndpoint);
-			if (body) importedZodSchemas.push(body.zodSchema);
-			config.update = {
-				acl: getAclConfig(updateEndpoint, resolver.options),
-				mutation: getImportedQueryName(updateEndpoint, resolver.options),
-				inputDefs: getInputsConfig(resolver, body)
-			};
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.update = {
+					acl: getAclConfig(updateEndpoint, resolver.options),
+					schema: getImportedZodSchemaName(resolver, body.zodSchema),
+					mutation: updateEndpoint,
+					inputDefs: getInputsConfig(resolver, body)
+				};
+			}
 		}
 		const deleteEndpoint = extendedEndpoints.find((endpoint) => isDeleteEndpoint(endpoint, readAllEndpoint));
 		if (deleteEndpoint) {
 			importedEndpoints.push(deleteEndpoint);
-			config.delete = {
-				acl: getAclConfig(deleteEndpoint, resolver.options),
-				mutation: getImportedQueryName(deleteEndpoint, resolver.options)
-			};
+			const body = getEndpointBody$1(deleteEndpoint);
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.delete = {
+					acl: getAclConfig(deleteEndpoint, resolver.options),
+					mutation: deleteEndpoint
+				};
+			}
 		}
 		const bulkDeleteEndpoint = extendedEndpoints.find((endpoint) => isBulkDeleteEndpoint(endpoint, readAllEndpoint));
 		if (bulkDeleteEndpoint) {
 			importedEndpoints.push(bulkDeleteEndpoint);
 			const body = getEndpointBody$1(bulkDeleteEndpoint);
-			if (body) importedZodSchemas.push(body.zodSchema);
-			config.bulkDelete = {
-				acl: getAclConfig(bulkDeleteEndpoint, resolver.options),
-				mutation: getImportedQueryName(bulkDeleteEndpoint, resolver.options),
-				inputDefs: getInputsConfig(resolver, body)
-			};
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.bulkDelete = {
+					acl: getAclConfig(bulkDeleteEndpoint, resolver.options),
+					schema: getImportedZodSchemaName(resolver, body.zodSchema),
+					mutation: bulkDeleteEndpoint,
+					inputDefs: getInputsConfig(resolver, body)
+				};
+			}
 		}
 		return config;
 	});
@@ -3359,12 +3384,70 @@ function getSchemaProperties(resolver, schema) {
 	return {};
 }
 
+//#endregion
+//#region src/generators/const/queries.const.ts
+const QUERY_HOOKS = {
+	query: "useQuery",
+	infiniteQuery: "useInfiniteQuery",
+	mutation: "useMutation"
+};
+const QUERY_IMPORT = {
+	bindings: [
+		QUERY_HOOKS.query,
+		QUERY_HOOKS.infiniteQuery,
+		QUERY_HOOKS.mutation
+	],
+	from: "@tanstack/react-query"
+};
+const QUERIES_MODULE_NAME = "moduleName";
+
 //#endregion
 //#region src/generators/generate/generateConfigs.ts
 function generateConfigs(generateTypeParams) {
-	const { configs, hasZodImport, modelsImports, queriesImports, aclImports } = getBuilderConfigs(generateTypeParams);
+	const { configs, hasZodImport, modelsImports, aclImports } = getBuilderConfigs(generateTypeParams);
 	if (configs.length === 0) return;
 	const { resolver, tag } = generateTypeParams;
+	const endpoints = configs.flatMap((config) => [
+		config.create?.mutation,
+		config.update?.mutation,
+		config.delete?.mutation,
+		config.bulkDelete?.mutation
+	]).filter((m) => typeof m !== "string" && m !== void 0);
+	const hasMutation = endpoints.length > 0;
+	resolver.options.checkAcl && endpoints.some((e) => e.acl);
+	const hasMutationEffects = resolver.options.mutationEffects && hasMutation;
+	const hasWorkspaceContext = resolver.options.workspaceContext && endpoints.some((e) => resolver.options.workspaceContext);
+	const endpointsImports = getEndpointsImports({
+		tag,
+		endpoints,
+		options: resolver.options
+	});
+	const queryImport = {
+		bindings: [QUERY_HOOKS.mutation],
+		from: "@tanstack/react-query"
+	};
+	const queryTypesImport = {
+		bindings: ["OpenApiQueryConfig"],
+		typeBindings: [QUERY_OPTIONS_TYPES.mutation],
+		from: getQueryTypesImportPath(resolver.options)
+	};
+	const mutationEffectsImport = {
+		bindings: [MUTATION_EFFECTS.hookName],
+		typeBindings: [MUTATION_EFFECTS.optionsType],
+		from: PACKAGE_IMPORT_PATH
+	};
+	const queryModulesImport = {
+		bindings: [QUERY_MODULE_ENUM],
+		from: getQueryModulesImportPath(resolver.options)
+	};
+	const aclCheckImport = {
+		bindings: [ACL_CHECK_HOOK],
+		from: ACL_PACKAGE_IMPORT_PATH
+	};
+	const workspaceContextImport = {
+		bindings: ["OpenApiWorkspaceContext"],
+		from: PACKAGE_IMPORT_PATH
+	};
 	const hasDynamicInputsImport = configs.some((config) => config.readAll.filters || config.create?.inputDefs || config.update?.inputDefs);
 	const dynamicInputsImport = {
 		bindings: [BUILDERS_UTILS.dynamicInputs],
@@ -3380,7 +3463,17 @@ function generateConfigs(generateTypeParams) {
 	if (hasDynamicInputsImport) lines.push(renderImport$3(dynamicInputsImport));
 	if (hasDynamicColumnsImport) lines.push(renderImport$3(dynamicColumnsImport));
 	for (const modelsImport of modelsImports) lines.push(renderImport$3(modelsImport));
-	for (const queriesImport of queriesImports) lines.push(renderImport$3(queriesImport));
+	for (const endpointsImport of endpointsImports) lines.push(renderImport$3(endpointsImport));
+	if (hasMutation) {
+		lines.push(renderImport$3(queryImport));
+		lines.push(renderImport$3(queryTypesImport));
+		if (hasMutationEffects) {
+			lines.push(renderImport$3(queryModulesImport));
+			lines.push(renderImport$3(mutationEffectsImport));
+		}
+		lines.push(renderImport$3(aclCheckImport));
+		if (hasWorkspaceContext) lines.push(renderImport$3(workspaceContextImport));
+	}
 	for (const aclImport of aclImports) lines.push(renderImport$3(aclImport));
 	lines.push("");
 	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
@@ -3389,7 +3482,7 @@ function generateConfigs(generateTypeParams) {
 		options: resolver.options
 	})} {`);
 	for (const config of configs) {
-		lines.push(renderBuilderConfig(config));
+		lines.push(renderBuilderConfig(config, generateTypeParams));
 		lines.push("");
 	}
 	if (resolver.options.tsNamespaces) lines.push("}");
@@ -3425,7 +3518,48 @@ function renderColumnsConfig(columnsConfig) {
 	lines.push("}");
 	return lines.join("\n");
 }
-function renderBuilderConfig(config) {
+function renderMutationContent(resolver, endpoint, tag) {
+	const hasAclCheck = resolver.options.checkAcl && endpoint.acl;
+	const hasMutationEffects = resolver.options.mutationEffects;
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const endpointTag = getEndpointTag(endpoint, resolver.options);
+	const endpointParams = mapEndpointParamsToFunctionParams(resolver, endpoint, {
+		includeFileParam: true,
+		modelNamespaceTag: endpointTag
+	});
+	const endpointParamsStr = endpointParams.map((p) => `${p.name}${p.required ? "" : "?"}: ${p.type}`).join("; ");
+	const destructuredMutationArgs = endpointParams.map((p) => p.name).join(", ");
+	const endpointFunction = getImportedEndpointName(endpoint, resolver.options);
+	const mutationVariablesType = endpoint.mediaUpload ? `{ ${endpointParamsStr}${endpointParamsStr ? "; " : ""}abortController?: AbortController; onUploadProgress?: (progress: { loaded: number; total: number }) => void }` : `{ ${endpointParamsStr} }`;
+	const lines = [];
+	lines.push(`(options?: AppMutationOptions<typeof ${endpointFunction}, ${mutationVariablesType}>${hasAxiosRequestConfig ? `, config?: AxiosRequestConfig` : ""}) => {`);
+	lines.push("  const queryConfig = OpenApiQueryConfig.useConfig();");
+	if (hasMutationEffects) lines.push(`  const { runMutationEffects } = useMutationEffects<typeof ${QUERY_MODULE_ENUM}.${endpointTag}>({ currentModule: ${QUERY_MODULE_ENUM}.${tag} });`);
+	lines.push(`  const { checkAcl } = ${ACL_CHECK_HOOK}();`);
+	lines.push("");
+	lines.push(`  return ${QUERY_HOOKS.mutation}({`);
+	const mutationFnArg = destructuredMutationArgs ? `{ ${destructuredMutationArgs}${endpoint.mediaUpload ? `${destructuredMutationArgs ? ", " : ""}abortController, onUploadProgress` : ""} }` : "";
+	lines.push(`    mutationFn: (${mutationFnArg}) => {`);
+	if (hasAclCheck) lines.push(`      checkAcl(${getNamespaceName({
+		type: GenerateType.Acl,
+		tag: endpointTag,
+		options: resolver.options
+	})}.canUse${capitalize(snakeToCamel(endpoint.operationName))}({ ${destructuredMutationArgs} }));`);
+	lines.push(`      return ${endpointFunction}(${destructuredMutationArgs}${hasAxiosRequestConfig ? `${destructuredMutationArgs ? ", " : ""}config` : ""});`);
+	lines.push("    },");
+	if (hasMutationEffects) {
+		lines.push("    onSuccess: async (...args) => {");
+		lines.push("      await runMutationEffects();");
+		lines.push("      await options?.onSuccess?.(...args);");
+		lines.push("    },");
+	}
+	lines.push("    ...options,");
+	lines.push("  });");
+	lines.push("}");
+	return lines.map((line) => "        " + line).join("\n").trimStart();
+}
+function renderBuilderConfig(config, params) {
+	const { resolver, tag } = params;
 	const lines = [];
 	lines.push(`export const ${config.name} = {`);
 	lines.push("    meta: {");
@@ -3454,23 +3588,31 @@ function renderBuilderConfig(config) {
 	if (config.create) {
 		lines.push("    create: {");
 		if (config.create.acl) lines.push(`        acl: ${config.create.acl},`);
-		if (config.create.inputDefs) lines.push(`        schema: ${config.create.inputDefs.schema},`);
-		lines.push(`        mutation: ${config.create.mutation},`);
+		if (config.create.schema) lines.push(`        schema: ${config.create.schema},`);
+		lines.push(`        mutation: ${typeof config.create.mutation === "string" ? config.create.mutation : renderMutationContent(resolver, config.create.mutation, tag)},`);
 		if (config.create.inputDefs) lines.push(`        inputDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.create.inputDefs)})`);
 		lines.push("    },");
 	}
 	if (config.update) {
 		lines.push("    update: {");
 		if (config.update.acl) lines.push(`        acl: ${config.update.acl},`);
-		if (config.update.inputDefs) lines.push(`        schema: ${config.update.inputDefs.schema},`);
-		lines.push(`        mutation: ${config.update.mutation},`);
+		if (config.update.schema) lines.push(`        schema: ${config.update.schema},`);
+		lines.push(`        mutation: ${typeof config.update.mutation === "string" ? config.update.mutation : renderMutationContent(resolver, config.update.mutation, tag)},`);
 		if (config.update.inputDefs) lines.push(`        inputDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.update.inputDefs)})`);
 		lines.push("    },");
 	}
 	if (config.delete) {
 		lines.push("    delete: {");
 		if (config.delete.acl) lines.push(`        acl: ${config.delete.acl},`);
-		lines.push(`        mutation: ${config.delete.mutation},`);
+		lines.push(`        mutation: ${typeof config.delete.mutation === "string" ? config.delete.mutation : renderMutationContent(resolver, config.delete.mutation, tag)},`);
+		lines.push("    },");
+	}
+	if (config.bulkDelete) {
+		lines.push("    bulkDelete: {");
+		if (config.bulkDelete.acl) lines.push(`        acl: ${config.bulkDelete.acl},`);
+		if (config.bulkDelete.schema) lines.push(`        schema: ${config.bulkDelete.schema},`);
+		lines.push(`        mutation: ${typeof config.bulkDelete.mutation === "string" ? config.bulkDelete.mutation : renderMutationContent(resolver, config.bulkDelete.mutation, tag)},`);
+		if (config.bulkDelete.inputDefs) lines.push(`        inputDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.bulkDelete.inputDefs)})`);
 		lines.push("    },");
 	}
 	lines.push("};");
@@ -3725,23 +3867,6 @@ function renderModelJsDocs({ name, zodSchema, tag, resolver }) {
 	return lines.join("\n");
 }
 
-//#endregion
-//#region src/generators/const/queries.const.ts
-const QUERY_HOOKS = {
-	query: "useQuery",
-	infiniteQuery: "useInfiniteQuery",
-	mutation: "useMutation"
-};
-const QUERY_IMPORT = {
-	bindings: [
-		QUERY_HOOKS.query,
-		QUERY_HOOKS.infiniteQuery,
-		QUERY_HOOKS.mutation
-	],
-	from: "@tanstack/react-query"
-};
-const QUERIES_MODULE_NAME = "moduleName";
-
 //#endregion
 //#region src/generators/generate/generateQueries.ts
 const endpointParamMappingCache = /* @__PURE__ */ new WeakMap();

package/dist/generator.d.mts

@@ -1,4 +1,4 @@
-import { n as GenerateFileData, t as GenerateOptions } from "./options-BNqkO_OS.mjs";
+import { n as GenerateFileData, t as GenerateOptions } from "./options-PQDrYdAn.mjs";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/generators/types/metadata.d.ts

package/dist/generator.mjs

@@ -1,4 +1,4 @@
-import { _ as isMediaTypeAllowed, b as formatTag, c as getSchemaTsMetaType, d as getTagImportPath, f as getQueryName, h as GenerateType, i as getDataFromOpenAPIDoc, l as getTsTypeBase, m as getNamespaceName, o as isMutation, p as DEFAULT_GENERATE_OPTIONS, s as isQuery, t as generateCodeFromOpenAPIDoc, v as isParamMediaTypeAllowed, y as invalidVariableNameCharactersToCamel } from "./generateCodeFromOpenAPIDoc-vrPucfhY.mjs";
+import { _ as isMediaTypeAllowed, b as formatTag, c as getSchemaTsMetaType, d as getTagImportPath, f as getQueryName, h as GenerateType, i as getDataFromOpenAPIDoc, l as getTsTypeBase, m as getNamespaceName, o as isMutation, p as DEFAULT_GENERATE_OPTIONS, s as isQuery, t as generateCodeFromOpenAPIDoc, v as isParamMediaTypeAllowed, y as invalidVariableNameCharactersToCamel } from "./generateCodeFromOpenAPIDoc-C7btBlMx.mjs";
 import SwaggerParser from "@apidevtools/swagger-parser";
 
 //#region src/generators/core/getMetadataFromOpenAPIDoc.ts

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { a as GeneralErrorCodes, i as ErrorHandlerOptions, n as ErrorEntry, o as SharedErrorHandler, r as ErrorHandler, t as ApplicationException } from "./error-handling-CXeVTk1T.mjs";
-import "./options-BNqkO_OS.mjs";
-import { t as OpenAPICodegenConfig } from "./config-BHkVxL6S.mjs";
+import "./options-PQDrYdAn.mjs";
+import { t as OpenAPICodegenConfig } from "./config-HbwoMgWr.mjs";
 import { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosResponseHeaders, CreateAxiosDefaults } from "axios";
 import { z } from "zod";
 import "i18next";

package/dist/{options-BNqkO_OS.d.mts → options-PQDrYdAn.d.mts}

@@ -12,6 +12,7 @@ interface GenerateFileData {
   fileName: string;
   content: string;
 }
+type GenerateFileFormatter = (file: GenerateFileData) => string | Promise<string>;
 //#endregion
 //#region src/generators/types/options.d.ts
 interface ZodGenerateOptions {
@@ -88,4 +89,4 @@ interface BaseGenerateOptions {
 }
 interface GenerateOptions extends BaseGenerateOptions, ZodGenerateOptions, EndpointsGenerateOptions, QueriesGenerateOptions, InfiniteQueriesGenerateOptions, ACLGenerateOptions, BuilderConfigsGenerateOptions {}
 //#endregion
-export { GenerateFileData as n, GenerateOptions as t };
+export { GenerateFileData as n, GenerateFileFormatter as r, GenerateOptions as t };

package/dist/sh.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { S as VALIDATION_ERROR_TYPE_TITLE, g as groupByType, h as GenerateType, i as getDataFromOpenAPIDoc, n as getOutputFileName, u as getTagFileName, x as Profiler } from "./generateCodeFromOpenAPIDoc-vrPucfhY.mjs";
-import { n as resolveConfig, t as runGenerate } from "./generate.runner-DKpRoYsX.mjs";
+import { S as VALIDATION_ERROR_TYPE_TITLE, g as groupByType, h as GenerateType, i as getDataFromOpenAPIDoc, n as getOutputFileName, u as getTagFileName, x as Profiler } from "./generateCodeFromOpenAPIDoc-C7btBlMx.mjs";
+import { n as resolveConfig, t as runGenerate } from "./generate.runner-C7QVcw6n.mjs";
 import { createRequire } from "node:module";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -39,7 +39,7 @@ function logBanner(message) {
 * Fetch the version from package.json
 */
 function getVersion() {
-	return "2.0.8-rc.23";
+	return "2.0.8-rc.25";
 }
 
 //#endregion

package/dist/vite.d.mts

@@ -1,8 +1,11 @@
-import "./options-BNqkO_OS.mjs";
-import { t as OpenAPICodegenConfig } from "./config-BHkVxL6S.mjs";
+import { r as GenerateFileFormatter } from "./options-PQDrYdAn.mjs";
+import { t as OpenAPICodegenConfig } from "./config-HbwoMgWr.mjs";
 import { Plugin } from "vite";
 
 //#region src/vite/openapi-codegen.plugin.d.ts
-declare function openApiCodegen(config: OpenAPICodegenConfig): Plugin;
+type OpenApiCodegenViteConfig = OpenAPICodegenConfig & {
+  formatGeneratedFile?: GenerateFileFormatter;
+};
+declare function openApiCodegen(config: OpenApiCodegenViteConfig): Plugin;
 //#endregion
-export { type OpenAPICodegenConfig, openApiCodegen };
+export { type OpenAPICodegenConfig, type OpenApiCodegenViteConfig, openApiCodegen };

package/dist/vite.mjs

@@ -1,5 +1,5 @@
-import { x as Profiler } from "./generateCodeFromOpenAPIDoc-vrPucfhY.mjs";
-import { t as runGenerate } from "./generate.runner-DKpRoYsX.mjs";
+import { x as Profiler } from "./generateCodeFromOpenAPIDoc-C7btBlMx.mjs";
+import { t as runGenerate } from "./generate.runner-C7QVcw6n.mjs";
 import path from "path";
 
 //#region src/vite/openapi-codegen.plugin.ts
@@ -7,13 +7,14 @@ function openApiCodegen(config) {
 	let resolvedViteConfig;
 	let queue = Promise.resolve();
 	const isLocalInput = typeof config.input === "string" && !/^https?:\/\//i.test(config.input);
-	const normalizedConfig = { ...config };
+	const { formatGeneratedFile, ...normalizedConfig } = config;
 	const enqueueGenerate = () => {
 		queue = queue.then(async () => {
 			const currentConfig = resolvedViteConfig;
 			if (!currentConfig) return;
 			await runGenerate({
 				fileConfig: normalizePaths(normalizedConfig, currentConfig.root),
+				formatGeneratedFile,
 				profiler: new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1")
 			});
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@povio/openapi-codegen-cli",
-  "version": "2.0.8-rc.23",
+  "version": "2.0.8-rc.25",
   "keywords": [
     "codegen",
     "openapi",
@@ -74,12 +74,12 @@
     "@apidevtools/swagger-parser": "^10.1.0",
     "i18next": "^25.8.13",
     "import-fresh": "^3.3.1",
+    "openapi-types": "^12.1.3",
     "prompt-sync": "^4.2.0",
     "reflect-metadata": "^0.2.2",
     "ts-pattern": "^5.9.0",
     "typescript": "^5.9.3",
-    "yargs": "^18.0.0",
-    "openapi-types": "^12.1.3"
+    "yargs": "^18.0.0"
   },
   "devDependencies": {
     "@casl/ability": "^6.8.0",