@moostjs/swagger 0.5.32 → 0.5.33

package/dist/index.mjs

@@ -1,11 +1,9 @@
 import { Const, Controller, Moost, getMoostMate, useControllerContext, useEventLogger } from "moost";
 import { Get, HeaderHook, SetHeader, StatusHook, Url } from "@moostjs/event-http";
-import { ZodSkip, getZodType, getZodTypeForProp, z } from "@moostjs/zod";
 import { THeaderHook, useSetHeaders } from "@wooksjs/event-http";
 import { serveFile } from "@wooksjs/http-static";
 import Path from "path";
 import { getAbsoluteFSPath } from "swagger-ui-dist";
-import { parseZodType } from "zod-parser";
 
 //#region packages/swagger/src/swagger.mate.ts
 function getSwaggerMate() {
@@ -53,7 +51,11 @@ function SwaggerExample(example) {
 
 //#endregion
 //#region packages/swagger/src/mapping.ts
+const globalSchemas = {};
+let schemaRefs = /* @__PURE__ */ new WeakMap();
+const nameToType = /* @__PURE__ */ new Map();
 function mapToSwaggerSpec(metadata, options, logger) {
+	resetSchemaRegistry();
 	const swaggerSpec = {
 		openapi: "3.0.0",
 		info: {
@@ -83,50 +85,30 @@ function mapToSwaggerSpec(metadata, options, logger) {
 				const newCode = code === "0" ? getDefaultStatusCode(handlerMethod) : code;
 				for (const [contentType, conf] of Object.entries(responseConfigs)) {
 					const { response, example } = conf;
-					const schema = getSwaggerSchemaFromSwaggerConfigType(response);
+					const schema = resolveSwaggerSchemaFromConfig(response);
 					if (schema) {
 						responses = responses || {};
-						responses[newCode] = { content: { [contentType]: { schema: {
+						const schemaWithExample = example !== void 0 ? {
 							...schema,
-							example: example || schema.example
-						} } } };
+							example
+						} : schema;
+						responses[newCode] = { content: { [contentType]: { schema: schemaWithExample } } };
 					}
 				}
 			}
 			else if (hmeta?.returnType) {
-				const parsed = myParseZod(getZodType({ type: hmeta.returnType }));
-				if ([
-					"ZodString",
-					"ZodNumber",
-					"ZodObject",
-					"ZodArray",
-					"ZodBoolean"
-				].includes(parsed.$type)) {
-					const schema = getSwaggerSchema(parsed);
-					if (schema) {
-						responses = responses || {};
-						responses[getDefaultStatusCode(handlerMethod)] = { content: { "*/*": { schema } } };
-					}
+				const ensured = ensureSchema(hmeta.returnType);
+				const schema = toSchemaOrRef(ensured);
+				if (schema) {
+					responses = responses || {};
+					responses[getDefaultStatusCode(handlerMethod)] = { content: { "*/*": { schema } } };
 				}
 			}
 			let reqBodyRequired = true;
-			const bodyConfig = {};
+			const bodyContent = {};
 			if (hmeta?.swaggerRequestBody) for (const [contentType, type] of Object.entries(hmeta.swaggerRequestBody)) {
-				let zt;
-				let schema;
-				if (type instanceof z.ZodType) zt = type;
-				else if (typeof type === "function") zt = getZodType({ type });
-				if (zt) {
-					const parsed = myParseZod(zt);
-					if ([
-						"ZodString",
-						"ZodNumber",
-						"ZodObject",
-						"ZodArray",
-						"ZodBoolean"
-					].includes(parsed.$type)) schema = getSwaggerSchema(parsed);
-				}
-				bodyConfig[contentType] = { schema };
+				const schema = resolveSwaggerSchemaFromConfig(type);
+				if (schema) bodyContent[contentType] = { schema };
 			}
 			swaggerSpec.paths[handlerPath][handlerMethod] = {
 				summary: handlerDescription,
@@ -152,298 +134,360 @@ function mapToSwaggerSpec(metadata, options, logger) {
 				in: param.in,
 				description: param.description,
 				required: !!param.required,
-				schema: getSwaggerSchemaFromSwaggerConfigType(param.type) || { type: "string" }
+				schema: resolveSwaggerSchemaFromConfig(param.type) || { type: "string" }
 			});
 			for (const param of hmeta?.swaggerParams || []) addParam({
 				name: param.name,
 				in: param.in,
 				description: param.description,
 				required: !!param.required,
-				schema: getSwaggerSchemaFromSwaggerConfigType(param.type) || { type: "string" }
+				schema: resolveSwaggerSchemaFromConfig(param.type) || { type: "string" }
 			});
 			for (const paramName of handler.registeredAs[0].args) {
 				const paramIndex = handler.meta.params.findIndex((param) => param.paramSource === "ROUTE" && param.paramName === paramName);
 				const paramMeta = handler.meta.params[paramIndex];
-				let schema;
-				let parsed;
-				if (paramMeta) {
-					const zodType = getZodTypeForProp({
-						type: controller.type,
-						key: handler.method,
-						index: paramIndex
-					}, {
-						type: paramMeta.type,
-						additionalMeta: paramMeta
-					}, void 0, logger);
-					parsed = myParseZod(zodType);
-					schema = getSwaggerSchema(parsed, true);
-				}
+				const ensured = ensureSchema(paramMeta?.type);
+				const schema = toSchemaOrRef(ensured) || { type: "string" };
 				addParam({
 					name: paramName,
 					in: "path",
 					description: paramMeta ? paramMeta.description : void 0,
-					required: !paramMeta.optional && !parsed?.$optional,
-					schema: schema || { type: "string" }
+					required: !paramMeta?.optional,
+					schema
 				});
 			}
 			for (let i = 0; i < handler.meta.params.length; i++) {
 				const paramMeta = handler.meta.params[i];
 				if (paramMeta.paramSource && ["QUERY_ITEM", "QUERY"].includes(paramMeta.paramSource)) {
-					const zodType = getZodTypeForProp({
-						type: controller.type,
-						key: handler.method,
-						index: i
-					}, {
-						type: paramMeta.type,
-						additionalMeta: paramMeta
-					}, void 0, logger);
-					const parsed = myParseZod(zodType);
-					const schema = getSwaggerSchema(parsed, true);
-					if (paramMeta.paramSource === "QUERY_ITEM") endpointSpec.parameters.push({
-						name: paramMeta.paramName || "",
-						in: "query",
-						description: paramMeta.description,
-						required: !paramMeta.optional && !parsed.$optional,
-						schema: schema || { type: "string" }
-					});
-					else if (paramMeta.paramSource === "QUERY" && parsed.$type === "ZodObject") for (const [key, value] of Object.entries(parsed.$inner)) {
-						const schema$1 = getSwaggerSchema(value, true);
-						if (schema$1) {
-							const swaggerSchema = {
-								name: key,
+					const ensured = ensureSchema(paramMeta.type);
+					if (paramMeta.paramSource === "QUERY_ITEM") {
+						const schema = toSchemaOrRef(ensured);
+						const normalized = schema ? normalizeQueryParamSchema(schema) : void 0;
+						endpointSpec.parameters.push({
+							name: paramMeta.paramName || "",
+							in: "query",
+							description: paramMeta.description,
+							required: !paramMeta.optional,
+							schema: normalized || { type: "string" }
+						});
+					} else if (paramMeta.paramSource === "QUERY") {
+						const schema = ensured?.schema;
+						if (schema?.type === "object" && schema.properties) {
+							const requiredProps = new Set(schema.required || []);
+							for (const [key, value] of Object.entries(schema.properties)) {
+								const propertySchema = cloneSchema(value);
+								const normalizedProperty = normalizeQueryParamSchema(propertySchema);
+								if (normalizedProperty) endpointSpec.parameters.push({
+									name: key,
+									in: "query",
+									description: normalizedProperty.description,
+									required: !paramMeta.optional && requiredProps.has(key),
+									schema: normalizedProperty
+								});
+							}
+						} else if (ensured) {
+							const schema$1 = toSchemaOrRef(ensured);
+							const normalized = schema$1 ? normalizeQueryParamSchema(schema$1) : void 0;
+							endpointSpec.parameters.push({
+								name: paramMeta.paramName || "",
 								in: "query",
-								description: value.description,
-								required: !parsed.$optional && !value.$optional,
-								schema: schema$1
-							};
-							endpointSpec.parameters.push(swaggerSchema);
+								description: paramMeta.description,
+								required: !paramMeta.optional,
+								schema: normalized || { type: "string" }
+							});
 						}
 					}
 				}
 				if (paramMeta.paramSource === "BODY") {
-					const zodType = getZodTypeForProp({
-						type: controller.type,
-						key: handler.method,
-						index: i
-					}, {
-						type: paramMeta.type,
-						additionalMeta: paramMeta
-					}, void 0, logger);
-					const parsed = myParseZod(zodType);
-					let contentType = "";
-					switch (parsed.$type) {
-						case "ZodString":
-						case "ZodNumber":
-						case "ZodBigInt":
-						case "ZodBoolean":
-						case "ZodDate":
-						case "ZodEnum":
-						case "ZodNativeEnum":
-						case "ZodLiteral": {
-							contentType = "text/plan";
-							break;
-						}
-						default: contentType = "application/json";
+					const ensured = ensureSchema(paramMeta.type);
+					const schema = toSchemaOrRef(ensured);
+					if (schema) {
+						const contentType = inferBodyContentType(schema, ensured?.schema);
+						if (!bodyContent[contentType]) bodyContent[contentType] = { schema };
+						reqBodyRequired = !paramMeta.optional;
 					}
-					if (!bodyConfig[contentType]) bodyConfig[contentType] = { schema: getSwaggerSchema(parsed) };
-					reqBodyRequired = !zodType.isOptional() && !paramMeta.optional;
 				}
 			}
-			if (bodyConfig && Object.entries(bodyConfig).some((e) => !!e[1])) swaggerSpec.paths[handlerPath][handlerMethod].requestBody = {
-				content: bodyConfig,
-				required: reqBodyRequired
-			};
+			const bodyEntries = Object.entries(bodyContent).filter((entry) => entry[1] && entry[1].schema !== void 0);
+			if (bodyEntries.length) {
+				const content = {};
+				for (const [contentType, { schema }] of bodyEntries) content[contentType] = { schema };
+				endpointSpec.requestBody = {
+					content,
+					required: reqBodyRequired
+				};
+			}
 		}
 	}
 	return swaggerSpec;
 }
-const globalSchemas = {};
-function getSwaggerSchema(parsed, forParam) {
-	const zodType = parsed.$ref;
-	const meta = zodType.__type_ref ? getSwaggerMate().read(zodType.__type_ref) : void 0;
-	if (!forParam && zodType.__type_ref && globalSchemas[zodType.__type_ref.name]) return { $ref: `#/components/schemas/${zodType.__type_ref.name}` };
-	if (forParam && zodType.__type_ref && globalSchemas[zodType.__type_ref.name]) return globalSchemas[zodType.__type_ref.name];
-	const schema = {};
-	if (meta) {
-		if (meta.swaggerExample) schema.example = meta.swaggerExample;
-		if (meta.label || meta.id) schema.title = meta.label || meta.id;
-		if (meta.description) schema.description = meta.description;
+function resolveSwaggerSchemaFromConfig(type) {
+	if (type === void 0) return void 0;
+	const ensured = ensureSchema(type);
+	return toSchemaOrRef(ensured);
+}
+function toSchemaOrRef(result) {
+	if (!result) return void 0;
+	if (result.ref) return { $ref: result.ref };
+	return cloneSchema(result.schema);
+}
+function inferBodyContentType(schema, resolved) {
+	const target = resolved ?? resolveSchemaFromRef(schema);
+	const schemaType = target?.type ?? schema.type;
+	if (schemaType && [
+		"string",
+		"number",
+		"integer",
+		"boolean"
+	].includes(schemaType)) return "text/plain";
+	return "application/json";
+}
+const SIMPLE_QUERY_TYPES = new Set([
+	"string",
+	"number",
+	"integer",
+	"boolean"
+]);
+function normalizeQueryParamSchema(schema) {
+	const target = resolveSchemaFromRef(schema) || schema;
+	if (!target) return void 0;
+	if (target.type === "array") return isArrayOfSimpleItems(target.items) ? schema : void 0;
+	return isSimpleSchema(schema) ? schema : void 0;
+}
+function isArrayOfSimpleItems(items) {
+	if (!items) return false;
+	if (Array.isArray(items)) {
+		if (items.length === 0) return false;
+		return items.every((entry) => isSimpleSchema(entry));
 	}
-	if (!forParam && zodType.__type_ref) globalSchemas[zodType.__type_ref.name] = schema;
-	function asString() {
-		schema.type = "string";
-		if (parsed.$checks) {
-			const { regex } = parsed.$checks;
-			if (regex) schema.pattern = regex.source;
-		}
+	return isSimpleSchema(items);
+}
+function isSimpleSchema(schema, seen = /* @__PURE__ */ new Set()) {
+	if (!schema) return false;
+	if (seen.has(schema)) return false;
+	seen.add(schema);
+	if (schema.$ref) {
+		const resolved = resolveSchemaFromRef(schema);
+		if (!resolved) return false;
+		return isSimpleSchema(resolved, seen);
 	}
-	function asLiteral() {
-		if (parsed.$type === "ZodLiteral") {
-			schema.type = "string";
-			schema.enum = [parsed.$value];
+	if (typeof schema.type === "string" && SIMPLE_QUERY_TYPES.has(schema.type)) return true;
+	if (Array.isArray(schema.enum) && schema.enum.length > 0) return true;
+	if (schema.const !== void 0) return true;
+	return false;
+}
+function resetSchemaRegistry() {
+	schemaRefs = /* @__PURE__ */ new WeakMap();
+	nameToType.clear();
+	for (const key of Object.keys(globalSchemas)) delete globalSchemas[key];
+}
+function ensureSchema(type) {
+	if (type === void 0 || type === null) return void 0;
+	const resolution = createSchemaResolution(type);
+	if (!resolution) return void 0;
+	if (resolution.kind === "inline") return {
+		schema: cloneSchema(resolution.schema),
+		isComponent: false
+	};
+	const schemaClone = cloneSchema(resolution.schema);
+	const componentName = ensureComponentName(resolution.typeRef, schemaClone, resolution.suggestedName);
+	return {
+		schema: cloneSchema(globalSchemas[componentName]),
+		ref: `#/components/schemas/${componentName}`,
+		componentName,
+		isComponent: true
+	};
+}
+function createSchemaResolution(type) {
+	if (type === void 0 || type === null) return void 0;
+	if (isSwaggerSchema(type)) return {
+		kind: "inline",
+		schema: cloneSchema(type)
+	};
+	if (Array.isArray(type)) {
+		if (type.length === 1) {
+			const itemEnsured = ensureSchema(type[0]);
+			const itemsSchema = toSchemaOrRef(itemEnsured);
+			return {
+				kind: "inline",
+				schema: {
+					type: "array",
+					items: itemsSchema
+				}
+			};
 		}
+		return {
+			kind: "inline",
+			schema: { type: "array" }
+		};
 	}
-	function asEnum() {
-		if (parsed.$type === "ZodEnum") {
-			schema.type = "string";
-			schema.enum = parsed.$value;
-		}
+	if (isLiteralValue(type)) return {
+		kind: "inline",
+		schema: schemaFromLiteral(type)
+	};
+	if (isPrimitiveConstructor(type)) return {
+		kind: "inline",
+		schema: schemaFromPrimitiveCtor(type)
+	};
+	if (typeof type === "function") {
+		const resolution = schemaFromFunction(type);
+		if (resolution) return resolution;
 	}
-	function asNativeEnum() {
-		if (parsed.$type === "ZodNativeEnum") {
-			schema.type = "string";
-			schema.enum = Object.keys(parsed.$value);
-		}
+	if (typeof type === "object") {
+		const resolution = schemaFromInstance(type);
+		if (resolution) return resolution;
 	}
-	if (forParam) switch (parsed.$type) {
-		case "ZodAny":
-		case "ZodUnknown":
-		case "ZodString": {
-			asString();
-			break;
-		}
-		case "ZodNumber": {
-			schema.type = "number";
-			break;
-		}
-		case "ZodBigInt": {
-			schema.type = "integer";
-			break;
-		}
-		case "ZodBoolean": {
-			schema.type = "boolean";
-			break;
-		}
-		case "ZodLiteral": {
-			asLiteral();
-			break;
-		}
-		case "ZodEnum": {
-			asEnum();
-			break;
-		}
-		case "ZodNativeEnum": {
-			asNativeEnum();
-			break;
-		}
-		case "ZodDate": {
-			schema.type = "string";
-			break;
-		}
-		case "ZodNull": {
-			schema.type = "null";
-			break;
-		}
-		default: return void 0;
+	return void 0;
+}
+function schemaFromFunction(fn) {
+	const ctor = fn;
+	if (typeof ctor.toJsonSchema === "function") {
+		const schema = asSwaggerSchema(ctor.toJsonSchema());
+		return {
+			kind: "component",
+			schema,
+			typeRef: ctor,
+			suggestedName: ctor.name
+		};
 	}
-	else switch (parsed.$type) {
-		case "ZodString": {
-			asString();
-			break;
-		}
-		case "ZodNumber": {
-			schema.type = "number";
-			break;
-		}
-		case "ZodBigInt": {
-			schema.type = "integer";
-			break;
-		}
-		case "ZodBoolean": {
-			schema.type = "boolean";
-			break;
-		}
-		case "ZodLiteral": {
-			asLiteral();
-			break;
-		}
-		case "ZodEnum": {
-			asEnum();
-			break;
-		}
-		case "ZodNativeEnum": {
-			asNativeEnum();
-			break;
-		}
-		case "ZodDate": {
-			schema.type = "string";
-			break;
-		}
-		case "ZodNull": {
-			schema.type = "null";
-			break;
-		}
-		case "ZodFunction":
-		case "ZodSymbol":
-		case "ZodUndefined":
-		case "ZodUnknown":
-		case "ZodNever":
-		case "ZodVoid":
-		case "ZodNaN": return void 0;
-		case "ZodArray": {
-			schema.type = "array";
-			schema.minItems = parsed.$checks?.minLength || void 0;
-			schema.maxItems = parsed.$checks?.maxLength || void 0;
-			schema.items = getSwaggerSchema(parsed.$inner);
-			break;
-		}
-		case "ZodTuple": {
-			schema.type = "array";
-			schema.items = parsed.$inner.map((t) => getSwaggerSchema(t)).filter((t) => !!t);
-			break;
-		}
-		case "ZodObject": {
-			schema.type = "object";
-			schema.properties = {};
-			schema.required = [];
-			if (zodType._def.unknownKeys === "passthrough") schema.additionalProperties = {};
-			for (const [key, val] of Object.entries(parsed.$inner)) {
-				const prop = getSwaggerSchema(val);
-				if (prop) {
-					schema.properties[key] = prop;
-					if (!val.$optional) schema.required.push(key);
-				}
-			}
-			break;
-		}
-		case "ZodPromise":
-		case "ZodRecord":
-		case "ZodMap":
-		case "ZodSet": {
-			schema.type = "object";
-			schema.properties = {};
-			schema.additionalProperties = parsed.$type === "ZodRecord" ? {} : void 0;
-			break;
-		}
-		case "ZodUnion":
-		case "ZodDiscriminatedUnion": {
-			schema.oneOf = parsed.$inner.map((t) => getSwaggerSchema(t)).filter((t) => !!t);
-			break;
-		}
-		case "ZodIntersection": {
-			schema.allOf = parsed.$inner.map((t) => getSwaggerSchema(t)).filter((t) => !!t);
-			break;
-		}
-		case "ZodLazy": return getSwaggerSchema(parsed.$get());
-		default: return void 0;
+	if (fn.length === 0) try {
+		const result = fn();
+		if (result && result !== fn) return createSchemaResolution(result);
+	} catch {}
+	return void 0;
+}
+function schemaFromInstance(obj) {
+	if (isSwaggerSchema(obj)) return {
+		kind: "inline",
+		schema: cloneSchema(obj)
+	};
+	const ctor = obj.constructor;
+	if (ctor && typeof ctor.toJsonSchema === "function") {
+		const schema = asSwaggerSchema(ctor.toJsonSchema());
+		return {
+			kind: "component",
+			schema,
+			typeRef: ctor,
+			suggestedName: ctor.name
+		};
 	}
-	if (parsed.$nullable) schema.nullable = parsed.$nullable;
-	if (parsed.$ref._def.description) schema.description = parsed.$ref._def.description;
-	if (parsed.$checks) {
-		const checks = parsed.$checks;
-		if (parsed.$type === "ZodString") {
-			if (typeof checks.min === "number") schema.minLength = checks.min;
-			if (typeof checks.max === "number") schema.maxLength = checks.max;
-		} else {
-			if (typeof checks.min === "number") schema.minimum = checks.min;
-			if (typeof checks.max === "number") schema.maximum = checks.max;
-		}
+	if (typeof obj.toJsonSchema === "function") {
+		const schema = asSwaggerSchema(obj.toJsonSchema());
+		return {
+			kind: "component",
+			schema,
+			typeRef: obj,
+			suggestedName: getTypeName(obj)
+		};
+	}
+	return void 0;
+}
+function asSwaggerSchema(schema) {
+	if (!schema || typeof schema !== "object") return {};
+	return cloneSchema(schema);
+}
+function ensureComponentName(typeRef, schema, suggestedName) {
+	const existing = schemaRefs.get(typeRef);
+	if (existing) {
+		if (!globalSchemas[existing]) globalSchemas[existing] = cloneSchema(schema);
+		return existing;
 	}
-	if (!forParam && zodType.__type_ref) return { $ref: `#/components/schemas/${zodType.__type_ref.name}` };
-	return schema;
+	const baseName = sanitizeComponentName(suggestedName || schema.title || getTypeName(typeRef) || "Schema");
+	let candidate = baseName || "Schema";
+	let counter = 1;
+	while (nameToType.has(candidate)) candidate = `${baseName}_${counter++}`;
+	nameToType.set(candidate, typeRef);
+	schemaRefs.set(typeRef, candidate);
+	applySwaggerMetadata(typeRef, schema);
+	globalSchemas[candidate] = cloneSchema(schema);
+	return candidate;
+}
+function applySwaggerMetadata(typeRef, schema) {
+	try {
+		const mate = getSwaggerMate();
+		const meta = mate.read(typeRef);
+		if (!meta) return;
+		if (meta.swaggerExample !== void 0 && schema.example === void 0) schema.example = meta.swaggerExample;
+		const title = meta.label || meta.id;
+		if (title && !schema.title) schema.title = title;
+		if (meta.swaggerDescription && !schema.description) schema.description = meta.swaggerDescription;
+		else if (meta.description && !schema.description) schema.description = meta.description;
+	} catch {}
+}
+function sanitizeComponentName(name) {
+	const sanitized = name.replace(/[^A-Za-z0-9_.-]/g, "_");
+	return sanitized || "Schema";
+}
+function getTypeName(typeRef) {
+	if (typeof typeRef === "function" && typeRef.name) return typeRef.name;
+	const ctor = typeRef.constructor;
+	if (ctor && ctor !== Object && ctor.name) return ctor.name;
+	return void 0;
+}
+function isSwaggerSchema(candidate) {
+	if (!candidate || typeof candidate !== "object") return false;
+	const obj = candidate;
+	return "$ref" in obj || "type" in obj || "properties" in obj || "items" in obj || "allOf" in obj || "anyOf" in obj || "oneOf" in obj;
 }
-function myParseZod(schema) {
-	return parseZodType(schema);
+function isLiteralValue(value) {
+	const type = typeof value;
+	return type === "string" || type === "number" || type === "boolean" || type === "bigint";
+}
+function schemaFromLiteral(value) {
+	if (typeof value === "string") {
+		if ([
+			"string",
+			"number",
+			"boolean",
+			"integer",
+			"object",
+			"array"
+		].includes(value)) return { type: value };
+		return {
+			const: value,
+			type: "string"
+		};
+	}
+	if (typeof value === "number") return {
+		const: value,
+		type: Number.isInteger(value) ? "integer" : "number"
+	};
+	if (typeof value === "boolean") return {
+		const: value,
+		type: "boolean"
+	};
+	return {
+		const: value.toString(),
+		type: "integer"
+	};
+}
+function isPrimitiveConstructor(value) {
+	if (typeof value !== "function") return false;
+	return value === String || value === Number || value === Boolean || value === BigInt || value === Date || value === Array || value === Object || value === Symbol;
+}
+function schemaFromPrimitiveCtor(fn) {
+	switch (fn) {
+		case String: return { type: "string" };
+		case Number: return { type: "number" };
+		case Boolean: return { type: "boolean" };
+		case BigInt: return { type: "integer" };
+		case Date: return {
+			type: "string",
+			format: "date-time"
+		};
+		case Array: return { type: "array" };
+		case Object: return { type: "object" };
+		case Symbol: return { type: "string" };
+		default: return { type: "object" };
+	}
+}
+function resolveSchemaFromRef(schema) {
+	if (!schema.$ref) return schema;
+	const refName = schema.$ref.replace("#/components/schemas/", "");
+	return globalSchemas[refName];
+}
+function cloneSchema(schema) {
+	return JSON.parse(JSON.stringify(schema));
 }
 function getDefaultStatusCode(httpMethod) {
 	const defaultStatusCodes = {
@@ -454,23 +498,6 @@ function getDefaultStatusCode(httpMethod) {
 	};
 	return defaultStatusCodes[httpMethod.toUpperCase()] || 200;
 }
-function getSwaggerSchemaFromSwaggerConfigType(type) {
-	let schema;
-	let zt;
-	if (type instanceof z.ZodType) zt = type;
-	else if (typeof type === "function") zt = getZodType({ type });
-	if (zt) {
-		const parsed = myParseZod(zt);
-		if ([
-			"ZodString",
-			"ZodNumber",
-			"ZodObject",
-			"ZodArray",
-			"ZodBoolean"
-		].includes(parsed.$type)) schema = getSwaggerSchema(parsed);
-	} else if (type.type || type.$ref) schema = type;
-	return schema;
-}
 
 //#endregion
 //#region packages/swagger/src/swagger.controller.ts
@@ -621,7 +648,6 @@ _ts_decorate([
 ], SwaggerController.prototype, "files", null);
 SwaggerController = _ts_decorate([
 	SwaggerExclude(),
-	ZodSkip(),
 	Controller("api-docs"),
 	_ts_param(0, Const({ title: "Moost API" })),
 	_ts_metadata("design:type", Function),