@povio/openapi-codegen-cli 2.0.8-rc.3 → 2.0.8-rc.31

package/dist/sh.mjs

@@ -0,0 +1,448 @@
+#!/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-DkNqNy-S.mjs";
+import { n as resolveConfig, t as runGenerate } from "./generate.runner-CXsHkwM7.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.31";
+}
+
+//#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, includeTags: _includeTagsParam, 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;
+	includeTags;
+	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: "includeTags" }), __decorateMetadata("design:type", String)], CheckOptions.prototype, "includeTags", 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;
+	clearOutput;
+	incremental;
+	tsNamespaces;
+	tsPath;
+	splitByTags;
+	defaultTag;
+	includeTags;
+	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: "clearOutput",
+	type: "boolean"
+}), __decorateMetadata("design:type", Boolean)], GenerateOptions.prototype, "clearOutput", 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: "includeTags" }), __decorateMetadata("design:type", String)], GenerateOptions.prototype, "includeTags", 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,11 @@
+import { r as GenerateFileFormatter } from "./options-D9TC-n26.mjs";
+import { t as OpenAPICodegenConfig } from "./config-KffSntOs.mjs";
+import { Plugin } from "vite";
+
+//#region src/vite/openapi-codegen.plugin.d.ts
+type OpenApiCodegenViteConfig = OpenAPICodegenConfig & {
+  formatGeneratedFile?: GenerateFileFormatter;
+};
+declare function openApiCodegen(config: OpenApiCodegenViteConfig): Plugin;
+//#endregion
+export { type OpenAPICodegenConfig, type OpenApiCodegenViteConfig, openApiCodegen };

package/dist/vite.mjs

@@ -0,0 +1,51 @@
+import { x as Profiler } from "./generateCodeFromOpenAPIDoc-DkNqNy-S.mjs";
+import { t as runGenerate } from "./generate.runner-CXsHkwM7.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 { 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")
+			});
+		});
+	};
+	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/dist/zod.d.mts

@@ -0,0 +1,20 @@
+import { r as ErrorHandler } from "./error-handling-CXeVTk1T.mjs";
+import { z } from "zod";
+
+//#region src/zod.d.ts
+declare namespace ZodExtended {
+  interface ParseOptions {
+    type: "body" | "query";
+    name?: string;
+    errorHandler?: ErrorHandler<never>;
+  }
+  export function parse<ZOutput, ZInput>(schema: z.ZodType<ZOutput, ZInput>, data: unknown, {
+    type,
+    name,
+    errorHandler
+  }?: ParseOptions): ZOutput;
+  export const sortExp: (enumSchema: z.ZodEnum) => z.ZodString;
+  export {};
+}
+//#endregion
+export { ZodExtended };

package/dist/zod.mjs

@@ -0,0 +1,33 @@
+import { r as SharedErrorHandler } from "./error-handling-DkPY7Asf.mjs";
+import { z } from "zod";
+
+//#region src/zod.ts
+let ZodExtended;
+(function(_ZodExtended) {
+	function parse(schema, data, { type, name, errorHandler } = { type: "body" }) {
+		try {
+			return schema.parse(data);
+		} catch (e) {
+			if (e instanceof z.ZodError) e.name = `FE Request ${type === "body" ? "body" : "query param"}${name ? ` ("${name}")` : ""} schema mismatch - ZodError`;
+			(errorHandler ?? SharedErrorHandler).rethrowError(e);
+			throw e;
+		}
+	}
+	_ZodExtended.parse = parse;
+	function isSortExpValid(enumSchema, data) {
+		if (data === void 0 || data === "" || enumSchema.options.length === 0) return true;
+		const prefixedEnumOptions = `([+-]?(${enumSchema.options.join("|")}))`;
+		const commaSeparatedOptions = `(${prefixedEnumOptions})(\\s*,\\s*${prefixedEnumOptions})*`;
+		return new RegExp(`^${commaSeparatedOptions}$`).test(data);
+	}
+	_ZodExtended.sortExp = (enumSchema) => z.string().superRefine((arg, ctx) => {
+		if (!isSortExpValid(enumSchema, arg)) ctx.addIssue({
+			code: "invalid_value",
+			message: "Invalid sorting string.",
+			values: []
+		});
+	});
+})(ZodExtended || (ZodExtended = {}));
+
+//#endregion
+export { ZodExtended };