@povio/openapi-codegen-cli 2.0.8-rc.5 → 2.0.8-rc.7

package/dist/sh.mjs

@@ -0,0 +1,439 @@
+#!/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-B5lnFNGB.mjs";
+import { n as resolveConfig, t as runGenerate } from "./generate.runner-DNldmk0f.mjs";
+import { createRequire } from "node:module";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { styleText } from "node:util";
+import fs, { existsSync, rmSync, writeFileSync } from "fs";
+import "reflect-metadata";
+import path from "path";
+import SwaggerParser from "@apidevtools/swagger-parser";
+import { exec } from "child_process";
+
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/helpers/cli.helper.ts
+function log(message) {
+	console.log(message);
+}
+function logInfo(message) {
+	console.log(`[INFO] ${message}`);
+}
+function logSuccess(message) {
+	console.log(styleText("green", `[SUCCESS] ${message}`));
+}
+function logError(error, message) {
+	if (error instanceof Error) console.log(styleText("red", `[ERROR] ${message || error.message}`));
+	else console.log(styleText("red", `[ERROR] ${error}`));
+}
+function logBanner(message) {
+	console.log(styleText("bgYellow", `==== ${message} ====`));
+}
+
+//#endregion
+//#region src/helpers/version.helper.ts
+/**
+* Fetch the version from package.json
+*/
+function getVersion() {
+	return "2.0.8-rc.7";
+}
+
+//#endregion
+//#region src/helpers/yargs.helper.ts
+const optionsKey = Symbol("options_key");
+function YargOption(properties) {
+	return (target, propertyKey) => {
+		if (properties !== void 0 && properties !== null) {
+			const newMetadata = {
+				...Reflect.getMetadata(optionsKey, target),
+				[propertyKey]: {
+					...properties,
+					describe: properties.envAlias ? `${properties.describe || ""} [${properties.envAlias}]` : properties.describe,
+					type: properties.type || Reflect.getMetadata("design:type", target, propertyKey)?.name?.toLowerCase()
+				}
+			};
+			Reflect.defineMetadata(optionsKey, newMetadata, target);
+		}
+	};
+}
+function getYargsOption(target) {
+	const options = Reflect.getMetadata(optionsKey, target.prototype);
+	if (!options) throw new Error(`Options for ${target.name} were not defined`);
+	return options;
+}
+function getBuilder(options) {
+	return async (y) => {
+		return y.options(getYargsOptions(options)).middleware(async (_argv) => {
+			return await loadYargsConfig(options, _argv);
+		}, true);
+	};
+}
+function getYargsOptions(target) {
+	return Object.entries(getYargsOption(target)).reduce((a, [property, options]) => {
+		a[property] = Object.fromEntries(Object.entries(options).filter(([optionName]) => !["envAlias", "default"].includes(optionName)));
+		return a;
+	}, {});
+}
+async function loadYargsConfig(cls, _argv) {
+	const argv = new cls();
+	for (const [name, o] of Object.entries(getYargsOption(cls))) argv[name] = _argv[name] ?? o.default;
+	return argv;
+}
+
+//#endregion
+//#region src/generators/checkOpenAPIDoc.ts
+function checkOpenAPIDoc(openApiDoc, options) {
+	const { resolver, data } = getDataFromOpenAPIDoc(openApiDoc, options);
+	if (resolver.validationErrors.length > 0) {
+		const groupedErrors = groupByType(resolver.validationErrors);
+		Object.entries(groupedErrors).forEach(([type, errorMessages]) => {
+			log(`${styleText("red", `${VALIDATION_ERROR_TYPE_TITLE[type]}:`)}\n${errorMessages.map((message) => `- ${message}`).join("\n")}\n`);
+		});
+	} else {
+		const outputs = [...data.keys()].reduce((acc, tag) => [...acc, ...getOutputFileNames(tag, options)], []);
+		log(`${styleText("green", "Outputs:")}\n${outputs.map((output) => `- ${output}`).join("\n")}\n`);
+	}
+	return resolver.validationErrors;
+}
+function getOutputFileNames(tag, options) {
+	return [
+		GenerateType.Models,
+		GenerateType.Endpoints,
+		GenerateType.Queries
+	].map((type) => getOutputFileName({
+		output: options.output,
+		fileName: getTagFileName({
+			tag,
+			type,
+			options
+		})
+	}));
+}
+
+//#endregion
+//#region src/helpers/config.helper.ts
+const CONFIG_FILE_NAMES = ["openapi-codegen.config.mjs", "openapi-codegen.config.ts"];
+async function loadConfig(configPath) {
+	try {
+		if (configPath) return await loadConfigFromPath(configPath);
+		for (const fileName of CONFIG_FILE_NAMES) {
+			const filePath = path.resolve(process.cwd(), fileName);
+			if (fs.existsSync(filePath)) return await loadConfigFromPath(filePath);
+		}
+		return null;
+	} catch (error) {
+		logError(`Failed to load configuration: ${error instanceof Error ? error.message : error}`);
+		return null;
+	}
+}
+async function loadConfigFromPath(filePath) {
+	const absolutePath = path.resolve(process.cwd(), filePath);
+	if (!fs.existsSync(absolutePath)) throw new Error(`Configuration file not found: ${filePath}`);
+	const ext = path.extname(absolutePath).toLowerCase();
+	if (ext === ".mjs") return loadMjsConfig(absolutePath);
+	if (ext !== ".ts") throw new Error(`Only ESM (.mjs) and TypeScript (.ts) configuration files are supported. Found: ${ext}`);
+	return loadTsConfig(absolutePath);
+}
+async function loadMjsConfig(filePath) {
+	const imported = await import(`${pathToFileURL(filePath).href}?t=${Date.now()}`);
+	if (!imported.default) throw new Error(`ESM config must have a default export: ${filePath}`);
+	return imported.default;
+}
+let importFresh;
+const loadJsSync = function loadJsSync(filepath) {
+	if (importFresh === void 0) importFresh = __require("import-fresh");
+	return importFresh(filepath);
+};
+let typescript;
+async function loadTsConfig(filePath) {
+	if (typescript === void 0) typescript = __require("typescript");
+	const transpiledFilepath = `${filePath.slice(0, -2)}cjs`;
+	try {
+		const tsConfig = resolveTsConfig(path.dirname(filePath)) ?? {};
+		tsConfig.compilerOptions = Object.assign({}, tsConfig.compilerOptions, {
+			module: typescript.ModuleKind.NodeNext,
+			moduleResolution: typescript.ModuleResolutionKind.NodeNext,
+			target: typescript.ScriptTarget.ES2022,
+			noEmit: false
+		});
+		const fileContent = fs.readFileSync(filePath, "utf-8");
+		const transpiledFileContent = typescript.transpileModule(fileContent, tsConfig).outputText;
+		writeFileSync(transpiledFilepath, transpiledFileContent);
+		return loadJsSync(transpiledFilepath).default;
+	} catch (error) {
+		error.message = `TypeScript Error in ${filePath}:\n${error.message}`;
+		throw error;
+	} finally {
+		if (existsSync(transpiledFilepath)) rmSync(transpiledFilepath);
+	}
+}
+function resolveTsConfig(directory) {
+	const filePath = typescript.findConfigFile(directory, (fileName) => {
+		return typescript.sys.fileExists(fileName);
+	});
+	if (filePath === void 0) return;
+	const { config, error } = typescript.readConfigFile(filePath, (path) => typescript.sys.readFile(path));
+	if (error) throw new Error(`Error in ${filePath}: ${error.messageText.toString()}`);
+	return config;
+}
+function pathToFileURL(filePath) {
+	const normalizedPath = path.resolve(filePath).replace(/\\/g, "/");
+	return { href: normalizedPath.startsWith("/") ? `file://${normalizedPath}` : `file:///${normalizedPath}` };
+}
+
+//#endregion
+//#region src/commands/check.ts
+async function check({ verbose, config: configParam, excludeTags: _excludeTagsParam, ...params }) {
+	const start = Date.now();
+	if (verbose) logInfo("Resolving config...");
+	const config = resolveConfig({
+		fileConfig: await loadConfig(configParam),
+		params
+	});
+	if (verbose) logInfo("Parsing OpenAPI spec...");
+	const openApiDoc = await SwaggerParser.bundle(config.input);
+	if (verbose) logInfo("Running check...");
+	const errorMessages = checkOpenAPIDoc(openApiDoc, config);
+	if (errorMessages.length === 0) logSuccess(`Time: ${Date.now() - start}ms`);
+	else throw new Error(`Found ${errorMessages.length} issues. Time: ${Date.now() - start}ms`);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.114.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.114.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/commands/check.command.ts
+var CheckOptions = class {
+	config;
+	input;
+	splitByTags;
+	defaultTag;
+	excludeTags;
+	excludePathRegex;
+	excludeRedundantZodSchemas;
+	verbose;
+};
+__decorate([YargOption({ envAlias: "config" }), __decorateMetadata("design:type", String)], CheckOptions.prototype, "config", void 0);
+__decorate([YargOption({ envAlias: "input" }), __decorateMetadata("design:type", String)], CheckOptions.prototype, "input", void 0);
+__decorate([YargOption({
+	envAlias: "splitByTags",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], CheckOptions.prototype, "splitByTags", void 0);
+__decorate([YargOption({ envAlias: "defaultTag" }), __decorateMetadata("design:type", String)], CheckOptions.prototype, "defaultTag", void 0);
+__decorate([YargOption({ envAlias: "excludeTags" }), __decorateMetadata("design:type", String)], CheckOptions.prototype, "excludeTags", void 0);
+__decorate([YargOption({ envAlias: "excludePathRegex" }), __decorateMetadata("design:type", String)], CheckOptions.prototype, "excludePathRegex", void 0);
+__decorate([YargOption({
+	envAlias: "excludeRedundantZodSchemas",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], CheckOptions.prototype, "excludeRedundantZodSchemas", void 0);
+__decorate([YargOption({
+	envAlias: "verbose",
+	default: false,
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], CheckOptions.prototype, "verbose", void 0);
+const command$1 = {
+	command: "check",
+	describe: "Check OpenAPI spec",
+	builder: getBuilder(CheckOptions),
+	handler: async (_argv) => {
+		const argv = await _argv;
+		if (argv.verbose) logBanner(`OpenAPI CodeGen ${getVersion()}`);
+		return check(argv);
+	}
+};
+
+//#endregion
+//#region src/commands/generate.ts
+async function generate({ prettier, verbose, config: configParam, ...params }) {
+	const start = Date.now();
+	const profiler = new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1");
+	const fileConfig = await profiler.runAsync("config.load", async () => await loadConfig(configParam));
+	if (verbose) logInfo("Generating code...");
+	const result = await runGenerate({
+		fileConfig,
+		params,
+		profiler
+	});
+	const config = result.config;
+	if (result.skipped && verbose) logInfo("OpenAPI and config unchanged. Skipping generation.");
+	if (verbose) {
+		logSuccess(`Time: ${Date.now() - start}ms`);
+		if (profiler.enabled) {
+			logInfo("Profile breakdown:");
+			profiler.formatLines().forEach((line) => logInfo(`  ${line}`));
+		}
+	}
+	if (prettier) execPrettier({
+		output: config.output,
+		verbose
+	});
+}
+function execPrettier({ output, verbose }) {
+	if (verbose) logInfo("Running Prettier...");
+	exec(`prettier --write ${output} `, (error) => {
+		if (verbose) if (error) logError(error, "Prettier error");
+		else logSuccess("Prettier finished.");
+	});
+}
+
+//#endregion
+//#region src/commands/generate.command.ts
+var GenerateOptions = class {
+	config;
+	input;
+	output;
+	incremental;
+	tsNamespaces;
+	tsPath;
+	splitByTags;
+	defaultTag;
+	excludeTags;
+	excludePathRegex;
+	excludeRedundantZodSchemas;
+	importPath;
+	extractEnums;
+	modelsInCommon;
+	removeOperationPrefixEndingWith;
+	acl;
+	checkAcl;
+	baseUrl;
+	replaceOptionalWithNullish;
+	infiniteQueries;
+	mutationEffects;
+	workspaceContext;
+	parseRequestParams;
+	inlineEndpoints;
+	inlineEndpointsExcludeModules;
+	modelsOnly;
+	axiosRequestConfig;
+	builderConfigs;
+	format;
+	verbose;
+};
+__decorate([YargOption({ envAlias: "config" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "config", void 0);
+__decorate([YargOption({ envAlias: "input" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "input", void 0);
+__decorate([YargOption({ envAlias: "output" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "output", void 0);
+__decorate([YargOption({
+	envAlias: "incremental",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "incremental", void 0);
+__decorate([YargOption({
+	envAlias: "tsNamespaces",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "tsNamespaces", void 0);
+__decorate([YargOption({ envAlias: "tsPath" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "tsPath", void 0);
+__decorate([YargOption({
+	envAlias: "splitByTags",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "splitByTags", void 0);
+__decorate([YargOption({ envAlias: "defaultTag" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "defaultTag", void 0);
+__decorate([YargOption({ envAlias: "excludeTags" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "excludeTags", void 0);
+__decorate([YargOption({ envAlias: "excludePathRegex" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "excludePathRegex", void 0);
+__decorate([YargOption({
+	envAlias: "excludeRedundantZodSchemas",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "excludeRedundantZodSchemas", void 0);
+__decorate([YargOption({ envAlias: "importPath" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "importPath", void 0);
+__decorate([YargOption({
+	envAlias: "extractEnums",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "extractEnums", void 0);
+__decorate([YargOption({
+	envAlias: "modelsInCommon",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "modelsInCommon", void 0);
+__decorate([YargOption({ envAlias: "removeOperationPrefixEndingWith" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "removeOperationPrefixEndingWith", void 0);
+__decorate([YargOption({
+	envAlias: "acl",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "acl", void 0);
+__decorate([YargOption({
+	envAlias: "checkAcl",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "checkAcl", void 0);
+__decorate([YargOption({ envAlias: "baseUrl" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "baseUrl", void 0);
+__decorate([YargOption({
+	envAlias: "replaceOptionalWithNullish",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "replaceOptionalWithNullish", void 0);
+__decorate([YargOption({
+	envAlias: "infiniteQueries",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "infiniteQueries", void 0);
+__decorate([YargOption({
+	envAlias: "mutationEffects",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "mutationEffects", void 0);
+__decorate([YargOption({
+	envAlias: "workspaceContext",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "workspaceContext", void 0);
+__decorate([YargOption({
+	envAlias: "parseRequestParams",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "parseRequestParams", void 0);
+__decorate([YargOption({
+	envAlias: "inlineEndpoints",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "inlineEndpoints", void 0);
+__decorate([YargOption({ envAlias: "inlineEndpointsExcludeModules" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "inlineEndpointsExcludeModules", void 0);
+__decorate([YargOption({
+	envAlias: "modelsOnly",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "modelsOnly", void 0);
+__decorate([YargOption({
+	envAlias: "axiosRequestConfig",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "axiosRequestConfig", void 0);
+__decorate([YargOption({
+	envAlias: "builderConfigs",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "builderConfigs", void 0);
+__decorate([YargOption({
+	envAlias: "format",
+	default: true,
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "format", void 0);
+__decorate([YargOption({
+	envAlias: "verbose",
+	default: false,
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "verbose", void 0);
+const command = {
+	command: "generate",
+	describe: "Generate code from OpenAPI spec",
+	builder: getBuilder(GenerateOptions),
+	handler: async (_argv) => {
+		const argv = await _argv;
+		if (argv.verbose) logBanner(`OpenAPI CodeGen ${getVersion()}`);
+		return generate(argv);
+	}
+};
+
+//#endregion
+//#region src/sh.ts
+yargs(hideBin(process.argv)).version(getVersion() || "unknown").scriptName("openapi-codegen").command(command).command(command$1).help().demandCommand(1).strictCommands(true).showHelpOnFail(true).fail((msg, err) => {
+	if (msg) logError(msg);
+	if (err) logError(err);
+	logInfo("Use '--help' for more info");
+	process.exit(1);
+}).parse();
+
+//#endregion
+export {  };

package/dist/vite.d.mts

@@ -0,0 +1,8 @@
+import "./options-DBz5YE3s.mjs";
+import { t as OpenAPICodegenConfig } from "./config-Cu_GYfai.mjs";
+import { Plugin } from "vite";
+
+//#region src/vite/openapi-codegen.plugin.d.ts
+declare function openApiCodegen(config: OpenAPICodegenConfig): Plugin;
+//#endregion
+export { type OpenAPICodegenConfig, openApiCodegen };

package/dist/vite.mjs

@@ -0,0 +1,50 @@
+import { x as Profiler } from "./generateCodeFromOpenAPIDoc-B5lnFNGB.mjs";
+import { t as runGenerate } from "./generate.runner-DNldmk0f.mjs";
+import path from "path";
+
+//#region src/vite/openapi-codegen.plugin.ts
+function openApiCodegen(config) {
+	let resolvedViteConfig;
+	let queue = Promise.resolve();
+	const isLocalInput = typeof config.input === "string" && !/^https?:\/\//i.test(config.input);
+	const normalizedConfig = { ...config };
+	const enqueueGenerate = () => {
+		queue = queue.then(async () => {
+			const currentConfig = resolvedViteConfig;
+			if (!currentConfig) return;
+			await runGenerate({
+				fileConfig: normalizePaths(normalizedConfig, currentConfig.root),
+				profiler: new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1")
+			});
+		});
+	};
+	const setupWatcher = (server) => {
+		if (!isLocalInput || !config.input) return;
+		const openApiPath = path.resolve(server.config.root, config.input);
+		server.watcher.add(openApiPath);
+		server.watcher.on("change", (changedPath) => {
+			if (path.resolve(changedPath) === openApiPath) enqueueGenerate();
+		});
+	};
+	return {
+		name: "openapi-codegen",
+		configResolved(config) {
+			resolvedViteConfig = config;
+		},
+		buildStart() {
+			enqueueGenerate();
+		},
+		configureServer(server) {
+			setupWatcher(server);
+		}
+	};
+}
+function normalizePaths(config, root) {
+	const normalized = { ...config };
+	if (typeof normalized.output === "string" && !path.isAbsolute(normalized.output)) normalized.output = path.resolve(root, normalized.output);
+	if (typeof normalized.input === "string" && !path.isAbsolute(normalized.input) && !/^https?:\/\//i.test(normalized.input)) normalized.input = path.resolve(root, normalized.input);
+	return normalized;
+}
+
+//#endregion
+export { openApiCodegen };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@povio/openapi-codegen-cli",
-  "version": "2.0.8-rc.5",
+  "version": "2.0.8-rc.7",
   "keywords": [
     "codegen",
     "openapi",
@@ -16,7 +16,7 @@
     "url": "git+https://github.com/povio/openapi-codegen-cli.git"
   },
   "bin": {
-    "openapi-codegen": "./dist/sh.js"
+    "openapi-codegen": "./dist/sh.mjs"
   },
   "files": [
     "README.md",
@@ -24,85 +24,88 @@
     "src/assets/**",
     "src/generators/templates/**"
   ],
+  "type": "module",
   "main": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.mjs"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.mts",
+      "import": "./dist/vite.mjs"
     },
     "./generator": {
-      "types": "./dist/generator.d.ts",
-      "import": "./dist/generator.js",
-      "require": "./dist/generator.js"
+      "types": "./dist/generator.d.mts",
+      "import": "./dist/generator.mjs"
     },
     "./acl": {
-      "types": "./dist/acl.d.ts",
-      "import": "./dist/acl.mjs",
-      "require": "./dist/acl.mjs"
+      "types": "./dist/acl.d.mts",
+      "import": "./dist/acl.mjs"
     }
   },
   "scripts": {
     "start": "node --import tsx ./src/sh.ts",
     "test": "vitest run",
     "test:watch": "vitest",
-    "build:clean": "rm -rf ./dist",
-    "build:client": "vite build",
-    "build:cli": "node ./esbuild.mjs && chmod +x ./dist/sh.js",
-    "build": "yarn build:clean && yarn build:cli && yarn build:client",
-    "start:dist": "node ./dist/sh.js",
+    "build": "tsdown",
+    "start:dist": "node ./dist/sh.mjs",
+    "gen:base": "rm -rf ./test/generated/base && mkdir -p ./test/generated/base && pnpm start generate --config ./test/config.mjs --output ./test/generated/base --no-prettier",
+    "gen:next": "rm -rf ./test/generated/next && mkdir -p ./test/generated/next && pnpm start generate --config ./test/config.mjs --output ./test/generated/next --no-prettier",
+    "test:generated-eq": "vitest run ./src/generators/generated-output-eq.test.ts",
+    "gen:verify": "pnpm gen:base && pnpm gen:next && pnpm test:generated-eq",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint --type-aware --fix",
     "lint:check": "oxlint --type-aware",
     "format": "oxfmt",
     "format:check": "oxfmt --check",
-    "check": "yarn typecheck && yarn lint && yarn test",
-    "push": "yarn exec ./scripts/publish.sh",
-    "dev:generate": "rm -rf ./output && yarn start generate --config ./test/config.ts",
-    "dev:check": "yarn start check --config ./test/config.ts"
+    "check": "pnpm typecheck && pnpm lint && pnpm test",
+    "push": "node ./scripts/publish.mjs",
+    "dev:generate": "rm -rf ./output && pnpm start generate --config ./test/config.mjs",
+    "dev:check": "pnpm start check --config ./test/config.mjs",
+    "snapshot:openapi-localhost": "node ./scripts/snapshot-openapi-localhost.mjs",
+    "bench:vite-codegen": "node ./scripts/benchmark-vite-codegen.mjs"
   },
   "dependencies": {
-    "i18next": "^25.8.10",
-    "import-fresh": "^3.3.1"
+    "@apidevtools/swagger-parser": "^10.1.0",
+    "handlebars": "^4.7.8",
+    "i18next": "^25.8.13",
+    "import-fresh": "^3.3.1",
+    "prompt-sync": "^4.2.0",
+    "reflect-metadata": "^0.2.2",
+    "ts-pattern": "^5.9.0",
+    "typescript": "^5.9.3",
+    "yargs": "^18.0.0"
   },
   "devDependencies": {
-    "@apidevtools/swagger-parser": "^10.1.0",
     "@casl/ability": "^6.8.0",
     "@casl/react": "^5.0.1",
     "@tanstack/react-query": "~5.90.21",
-    "@types/node": "^20.19.33",
+    "@types/node": "^25.3.0",
     "@types/prompt-sync": "^4.2.3",
     "@types/react": "^19.2.14",
     "@types/yargs": "^17.0.35",
     "@vitejs/plugin-react": "^5.1.4",
-    "axios": "^1.13.5",
-    "esbuild": "0.25.12",
-    "handlebars": "^4.7.8",
-    "openapi-types": "^12.1.3",
-    "oxfmt": "^0.33.0",
-    "oxlint": "^1.48.0",
-    "oxlint-tsgolint": "^0.14.0",
-    "prompt-sync": "^4.2.0",
+    "oxfmt": "^0.34.0",
+    "oxlint": "^1.50.0",
+    "oxlint-tsgolint": "^0.15.0",
     "react": "^19.2.4",
-    "reflect-metadata": "^0.2.2",
-    "ts-node": "^10.9.2",
-    "ts-pattern": "^5.9.0",
+    "tsdown": "^0.21.0-beta.1",
     "tsx": "^4.21.0",
-    "type-fest": "^4.41.0",
-    "typescript": "^5.9.3",
-    "vite": "^7.3.1",
+    "type-fest": "^5.4.4",
+    "vite": "npm:rolldown-vite@^7.3.1",
     "vite-plugin-dts": "^4.5.4",
-    "vitest": "3.2.4",
-    "yargs": "^17.7.2",
-    "zod": "^4.3.6"
+    "vitest": "4.0.18"
   },
   "peerDependencies": {
     "@casl/ability": "^6.7.3",
     "@casl/react": "^5.0.0",
     "@tanstack/react-query": "^5.90.21",
     "axios": "^1.13.1",
+    "openapi-types": "^12.1.3",
     "react": "^19.1.0",
+    "vite": "^6.0.0 || ^7.0.0",
     "zod": "^4.1.12"
   },
   "peerDependenciesMeta": {
@@ -111,12 +114,14 @@
     },
     "@casl/react": {
       "optional": true
+    },
+    "vite": {
+      "optional": true
     }
   },
   "engines": {
     "node": ">= 14",
-    "npm": ">= 8",
-    "yarn": ">= 3.2"
+    "pnpm": ">= 9"
   },
-  "packageManager": "yarn@4.2.2"
+  "packageManager": "pnpm@10.4.0"
 }

package/src/assets/useMutationEffects.ts

@@ -27,7 +27,12 @@ export function useMutationEffects({ currentModule }: UseMutationEffectsProps) {
   }, [queryClient, config.crossTabInvalidation]);
 
   const runMutationEffects = useCallback(
-    async <TData, TVariables>(data: TData, variables: TVariables, options: MutationEffectsOptions = {}, updateKeys?: QueryKey[]) => {
+    async <TData, TVariables>(
+      data: TData,
+      variables: TVariables,
+      options: MutationEffectsOptions = {},
+      updateKeys?: QueryKey[],
+    ) => {
       const { invalidateCurrentModule, invalidateModules, invalidateKeys, preferUpdate } = options;
       const shouldUpdate = preferUpdate ?? config.preferUpdate ?? false;
       const shouldInvalidateCurrentModule = invalidateCurrentModule ?? config.invalidateCurrentModule ?? true;