@huanglangjian/specs 0.2.0

package/dist/index.mjs

@@ -0,0 +1,843 @@
+import { resolve } from "pathe";
+import { format } from "prettier";
+import PrettierJavaPlugin from "prettier-plugin-java";
+import PrettierRustPlugin from "prettier-plugin-rust";
+//#region src/type-system/basic.ts
+function int32(options) {
+	return {
+		kind: "int32",
+		...options
+	};
+}
+function int64(options) {
+	return {
+		kind: "int64",
+		...options
+	};
+}
+function float32(options) {
+	return {
+		kind: "float32",
+		...options
+	};
+}
+function float64(options) {
+	return {
+		kind: "float64",
+		...options
+	};
+}
+function boolean(options) {
+	return {
+		kind: "boolean",
+		...options
+	};
+}
+function string(options) {
+	return {
+		kind: "string",
+		...options
+	};
+}
+function literal(options) {
+	return {
+		kind: "literal",
+		...options
+	};
+}
+/**
+* 创建一个可选类型模型。
+*
+* @param base 基础模型类型
+* @param options 可选配置选项
+* @returns 可选类型模型
+*/
+function optional(base, options) {
+	return {
+		kind: "optional",
+		base,
+		...options
+	};
+}
+function array(base, options) {
+	return {
+		kind: "array",
+		base,
+		...options
+	};
+}
+function set(base, options) {
+	return {
+		kind: "set",
+		base,
+		...options
+	};
+}
+function map(base, options) {
+	return {
+		kind: "map",
+		base,
+		...options
+	};
+}
+function record(options) {
+	return {
+		kind: "record",
+		...options
+	};
+}
+function union(options) {
+	return {
+		kind: "union",
+		...options
+	};
+}
+function datetime(options) {
+	return {
+		kind: "datetime",
+		...options
+	};
+}
+function date(options) {
+	return {
+		kind: "date",
+		...options
+	};
+}
+function duration(options) {
+	return {
+		kind: "duration",
+		...options
+	};
+}
+function error(options) {
+	return {
+		kind: "error",
+		...options
+	};
+}
+function enums(options) {
+	return {
+		kind: "enums",
+		...options
+	};
+}
+function generateJsonSchema(options) {
+	const { model, target = "draft-2020-12", reference = "json-schema", depth = 0 } = options ?? {};
+	const $schema = getSchemaRef(target);
+	const convert = (partial) => ({
+		$schema: depth === 0 ? $schema : void 0,
+		title: model.title,
+		description: model.description,
+		examples: model.examples,
+		deprecated: model.deprecated,
+		default: model.default,
+		...partial,
+		..."schema" in model ? model.schema : {}
+	});
+	const getReferenceSchema = (schema) => {
+		switch (reference) {
+			case "inline": return generateJsonSchema({
+				model: schema,
+				target,
+				reference,
+				depth: depth + 1
+			});
+			case "json-schema": return schema.id != null ? { $ref: "#/$defs/" + schema.id } : generateJsonSchema({
+				model: schema,
+				target,
+				reference,
+				depth: depth + 1
+			});
+			case "openapi": return schema.id != null ? { $ref: "#/components/schemas/" + schema.id } : generateJsonSchema({
+				model: schema,
+				target,
+				reference,
+				depth: depth + 1
+			});
+		}
+	};
+	switch (model.kind) {
+		case "int32": return convert({
+			type: "integer",
+			format: "int32"
+		});
+		case "float32": return convert({
+			type: "number",
+			format: "float"
+		});
+		case "float64": return convert({
+			type: "number",
+			format: "float"
+		});
+		case "int64": return convert({
+			type: "string",
+			format: "int64"
+		});
+		case "boolean": return convert({ type: "boolean" });
+		case "string": return convert({ type: "string" });
+		case "literal": return convert({ const: model.value });
+		case "optional": {
+			const baseSchema = getReferenceSchema(model.base);
+			if ("$ref" in baseSchema) return convert({ oneOf: [baseSchema, { type: "null" }] });
+			const { type = [], ...others } = baseSchema;
+			return convert({
+				type: Array.isArray(type) ? [...new Set([...type, "null"])] : [type, "null"],
+				...others
+			});
+		}
+		case "array": return convert({
+			type: "array",
+			items: getReferenceSchema(model.base)
+		});
+		case "set": return {
+			$schema,
+			type: "array",
+			items: getReferenceSchema(model.base),
+			uniqueItems: true
+		};
+		case "map": return convert({
+			type: "object",
+			additionalProperties: getReferenceSchema(model.base)
+		});
+		case "record": return convert({
+			type: "object",
+			properties: Object.fromEntries(Object.entries(model.properties).map(([k, v]) => [k, getReferenceSchema(v)])),
+			required: Object.entries(model.properties).filter(([_, v]) => v.kind !== "optional").map(([k]) => k),
+			additionalProperties: false
+		});
+		case "union": return convert({ oneOf: Object.entries(model.variants).map(([k, v]) => ({
+			type: "object",
+			title: v.title ?? k,
+			properties: { [k]: getReferenceSchema(v) },
+			required: [k],
+			additionalProperties: false
+		})) });
+		case "datetime": return convert({
+			type: "string",
+			format: "date-time"
+		});
+		case "date": return convert({
+			type: "string",
+			format: "date"
+		});
+		case "duration": return convert({
+			type: "string",
+			format: "duration"
+		});
+		case "error": return convert({
+			type: "object",
+			properties: {
+				code: { const: model.code },
+				context: model.context == null ? void 0 : {
+					type: "object",
+					properties: Object.fromEntries(Object.entries(model.context).map(([k, v]) => [k, getReferenceSchema(v)])),
+					additionalProperties: false
+				}
+			},
+			additionalProperties: false
+		});
+		case "enums": return convert({
+			type: "string",
+			enum: Object.values(model.variants)
+		});
+	}
+}
+function getSchemaRef(target) {
+	switch (target) {
+		case "draft-2020-12": return "https://json-schema.org/draft/2020-12/schema";
+	}
+}
+//#endregion
+//#region src/type-system/http.ts
+function generateOpenapi(options) {
+	const { info, routes, securitySchemes, tags, servers } = options;
+	const models = collectModelFromRoutes(routes);
+	return {
+		openapi: "3.2.0",
+		info,
+		paths: generatePathsObject(routes),
+		components: {
+			schemas: Object.fromEntries(generateComponentSchemasFromModels(models)),
+			securitySchemes
+		},
+		tags,
+		servers
+	};
+}
+function collectModelFromRoutes(routes) {
+	const models = /* @__PURE__ */ new Map();
+	for (const route of routes) for (const [id, model] of collectModelsFromRoute(route)) models.set(id, model);
+	return models;
+}
+function collectModelDeep(model) {
+	const ret = /* @__PURE__ */ new Map();
+	if (model.id != null) ret.set(model.id, model);
+	switch (model.kind) {
+		case "optional":
+		case "array":
+		case "set":
+		case "map":
+			for (const [id, nestModel] of collectModelDeep(model.base)) ret.set(id, nestModel);
+			return ret;
+		case "record":
+			for (const property of Object.values(model.properties)) for (const [id, nestedModel] of collectModelDeep(property)) ret.set(id, nestedModel);
+			return ret;
+		case "union":
+			for (const variant of Object.values(model.variants)) for (const [id, nestedModel] of collectModelDeep(variant)) ret.set(id, nestedModel);
+			return ret;
+		case "error":
+			if (model.context) for (const detail of Object.values(model.context)) for (const [id, nestedModel] of collectModelDeep(detail)) ret.set(id, nestedModel);
+			return ret;
+		default: return ret;
+	}
+}
+function collectModelsFromRoute(route) {
+	const models = /* @__PURE__ */ new Map();
+	for (const model of [
+		route.variables,
+		route.queries,
+		route.headers,
+		route.cookies
+	].filter((o) => !!o).flatMap(Object.values)) for (const [id, subModel] of collectModelDeep(model)) models.set(id, subModel);
+	if (route.content) for (const [id, subModel] of collectModelsFromContent(route.content)) models.set(id, subModel);
+	if (route.responses) for (const response of Object.values(route.responses)) for (const [id, subModel] of collectModelsFromResponse(response)) models.set(id, subModel);
+	return models;
+}
+function collectModelsFromContent(content) {
+	const models = /* @__PURE__ */ new Map();
+	if (content.kind !== "binary-stream-content") {
+		if (content.model) for (const [id, subModel] of collectModelDeep(content.model)) models.set(id, subModel);
+	}
+	return models;
+}
+function collectModelsFromResponse(response) {
+	const models = /* @__PURE__ */ new Map();
+	for (const model of [response.cookies, response.headers].filter((o) => !!o).flatMap(Object.values)) for (const [id, subModel] of collectModelDeep(model)) models.set(id, subModel);
+	if (response.content) for (const [id, subModel] of collectModelsFromContent(response.content)) models.set(id, subModel);
+	return models;
+}
+function generateComponentSchemasFromModels(models) {
+	const ret = /* @__PURE__ */ new Map();
+	for (const [id, model] of models) {
+		const schema = generateJsonSchema({
+			model,
+			reference: "openapi"
+		});
+		ret.set(id, schema);
+	}
+	return ret;
+}
+function generatePathsObject(routes) {
+	const pathItems = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const item = pathItems.get(route.path) ?? {};
+		pathItems.set(route.path, {
+			...item,
+			...generatePathItemObject(route)
+		});
+	}
+	return Object.fromEntries(pathItems);
+}
+function generatePathItemObject(route) {
+	return { [route.method]: generateOperationObject(route) };
+}
+function getSchemaReference(model) {
+	return model.id != null ? { $ref: "#/components/schemas/" + model.id } : generateJsonSchema({
+		model,
+		reference: "openapi"
+	});
+}
+function generateOperationObject(route) {
+	const { id, summary, description, variables, queries, headers, cookies, content, responses } = route;
+	const parameterObjects = [];
+	for (const [name, model] of Object.entries(variables)) parameterObjects.push({
+		in: "path",
+		name,
+		required: true,
+		schema: getSchemaReference(model)
+	});
+	if (queries) for (const [name, model] of Object.entries(queries)) parameterObjects.push({
+		in: "query",
+		name,
+		required: model.kind !== "optional",
+		schema: getSchemaReference(model)
+	});
+	if (headers) for (const [name, model] of Object.entries(headers)) parameterObjects.push({
+		in: "header",
+		name,
+		required: model.kind !== "optional",
+		schema: getSchemaReference(model)
+	});
+	if (cookies) for (const [name, model] of Object.entries(cookies)) parameterObjects.push({
+		in: "cookie",
+		name,
+		required: model.kind !== "optional",
+		schema: getSchemaReference(model)
+	});
+	const responseObjects = /* @__PURE__ */ new Map();
+	if (responses) for (const [name, response] of Object.entries(responses)) responseObjects.set(response.status.toString(), generateResponseObjectFromResponse(name, response));
+	return {
+		operationId: id,
+		summary: summary ?? route.id,
+		description,
+		parameters: parameterObjects,
+		responses: Object.fromEntries(responseObjects),
+		requestBody: content == null ? void 0 : generateRequestBodyObject(content)
+	};
+}
+function generateRequestBodyObject(content) {
+	switch (content.kind) {
+		case "plain-text-content":
+		case "json-content":
+		case "form-content": return { content: { [content.type]: generateMeidaTypeObject(content) } };
+		default: return {
+			description: content.description,
+			content: { [content.type]: generateMeidaTypeObject(content) }
+		};
+	}
+}
+function generateMeidaTypeObject(content) {
+	switch (content.kind) {
+		case "plain-text-content": return { schema: content.model ? getSchemaReference(content.model) : { type: "string" } };
+		case "plain-text-stream-content": return {
+			schema: {
+				type: "string",
+				format: "binary"
+			},
+			itemSchema: content.model ? getSchemaReference(content.model) : { type: "string" }
+		};
+		case "json-content": return { schema: getSchemaReference(content.model) };
+		case "json-stream-content": return {
+			schema: {
+				type: "string",
+				format: "binary"
+			},
+			itemSchema: getSchemaReference(content.model)
+		};
+		case "binary-stream-content": return {
+			schema: {
+				type: "string",
+				format: "binary"
+			},
+			itemSchema: {
+				type: "string",
+				format: "binary"
+			}
+		};
+		case "form-content": return { schema: getSchemaReference(content.model) };
+	}
+}
+function generateResponseObjectFromResponse(name, response) {
+	const headerObjects = /* @__PURE__ */ new Map();
+	if (response.headers) for (const [name, model] of Object.entries(response.headers)) headerObjects.set(name, {
+		schema: getSchemaReference(model),
+		required: model.kind !== "optional"
+	});
+	return {
+		description: response.description ?? name,
+		headers: headerObjects.size > 0 ? Object.fromEntries(headerObjects) : void 0,
+		content: response.content == null ? void 0 : { [response.content.type]: generateMeidaTypeObject(response.content) }
+	};
+}
+function route(options) {
+	return {
+		kind: "http-route",
+		...options
+	};
+}
+function plainText(options) {
+	return {
+		kind: "plain-text-content",
+		...options
+	};
+}
+function json(options) {
+	return {
+		kind: "json-content",
+		...options
+	};
+}
+function plainTextStream(options) {
+	return {
+		kind: "plain-text-stream-content",
+		...options
+	};
+}
+function jsonStream(options) {
+	return {
+		kind: "json-stream-content",
+		...options
+	};
+}
+function binary(options) {
+	return {
+		kind: "binary-stream-content",
+		...options
+	};
+}
+function form(options) {
+	return {
+		kind: "form-content",
+		...options
+	};
+}
+//#endregion
+//#region src/generator/java.ts
+function generateJavaClass(options) {
+	const { model, package: packageName } = options;
+	switch (model.kind) {
+		case "record": return `
+            package ${packageName};
+
+            import org.jspecify.annotations.NullMarked;
+
+            @NullMarked
+            public record ${model.id}(
+                ${Object.entries(model.properties).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generatePropertyCode(packageName, k, v))}
+            ){
+                ${Object.entries(model.properties).filter(([__dirname, v]) => v.kind === "literal").map(([k, v]) => generateStaticPropertyCode(packageName, k, v)).join(";")}
+            }
+        `;
+		case "union": return `
+            package ${packageName};
+
+            import org.jspecify.annotations.NullMarked;
+            
+            @NullMarked
+            public sealed interface ${model.id}{
+                ${Object.entries(model.variants).map(([k, v]) => generateUnionVariantCode(packageName, model.id, k, v)).join("\n")}
+            }
+        `;
+		case "error": return `
+            package ${packageName};
+
+            import org.jspecify.annotations.NullMarked;
+
+            @NullMarked
+            public record ${model.id}(Context context){
+                ${generateStaticPropertyCode(packageName, "code", literal({ value: model.code }))}
+
+                public ${model.id}(
+                    ${Object.entries(model.context ?? {}).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generatePropertyCode(packageName, k, v))}
+                ){
+                    this(new Context(${getPropertyNames(model.context)}));
+                }
+
+                public record Context(
+                    ${Object.entries(model.context ?? {}).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generatePropertyCode(packageName, k, v))}
+                ){
+                    ${Object.entries(model.context ?? {}).filter(([_, v]) => v.kind === "literal").map(([k, v]) => generateStaticPropertyCode(packageName, k, v)).join(";")}
+                }
+            }
+        `;
+		case "enums": return `
+                    
+            package ${packageName};
+
+            import org.jspecify.annotations.NullMarked;
+
+            public enum ${model.id} {
+
+                ${Object.entries(model.variants).map(([k, v]) => `${k}("${v}")`)};
+                
+                private final String value;
+
+                public ${model.id}(String value){
+                    this.value = value;
+                }
+
+                @com.fasterxml.jackson.annotation.JsonValue
+                public String getValue() { 
+                    return value;
+                }
+            }
+        `;
+	}
+}
+function getPropertyNames(properties) {
+	if (properties == null) return "";
+	return Object.keys(properties).join(",");
+}
+function generateUnionVariantCode(packageName, unionId, variantName, variant) {
+	switch (variant.kind) {
+		case "literal": return `
+            record ${variantName}() implements ${unionId} {
+                @com.fasterxml.jackson.annotation.JsonValue
+                ${generateStaticPropertyCode(packageName, "value", variant)}
+            }
+        `;
+		default: return `
+            record ${variantName}(
+                @com.fasterxml.jackson.annotation.JsonCreator
+                @com.fasterxml.jackson.annotation.JsonValue
+                ${generateModelSignature$1(packageName, variant)} value
+            ) implements ${unionId} {}
+        `;
+	}
+}
+function generatePropertyCode(packageName, name, property) {
+	return `${generateModelSignature$1(packageName, property)} ${name}`;
+}
+function generateStaticPropertyCode(packageName, name, property) {
+	return `public ${generateModelSignature$1(packageName, property)} ${name} = ${generateStaticValue$1(property.value)}`;
+}
+function generateStaticValue$1(value) {
+	switch (typeof value) {
+		case "string": return `"${value}"`;
+		case "boolean": return String(value);
+		case "number": return Number.isInteger(value) ? String(value) : value + "d";
+		default: throw Error("Unsupported literal value");
+	}
+}
+function generateModelSignature$1(packageName, model) {
+	switch (model.kind) {
+		case "string": return "String";
+		case "int32": return "int";
+		case "int64": return "long";
+		case "float32": return "float";
+		case "float64": return "double";
+		case "boolean": return "boolean";
+		case "date": return "java.time.LocalDate";
+		case "datetime": return "java.time.LocalDateTime";
+		case "duration": return "java.time.Duration";
+		case "array": return `Array<${generateModelSignature$1(packageName, model.base)}>`;
+		case "set": return `Set<${generateModelSignature$1(packageName, model.base)}>`;
+		case "map": return `Map<String, ${generateModelSignature$1(packageName, model.base)}>`;
+		case "optional": switch (model.base.kind) {
+			case "int32": return "@Nullable Integer";
+			case "int64": return "@Nullable Long";
+			case "float32": return "@Nullable Float";
+			case "float64": return "@Nullable Double";
+			case "boolean": return "@Nullable Boolean";
+			case "optional": return generateModelSignature$1(packageName, model.base);
+			default: return `@Nullable ${generateModelSignature$1(packageName, model.base)}`;
+		}
+		case "literal": switch (typeof model.value) {
+			case "string": return "String";
+			case "boolean": return "boolean";
+			case "number": return Number.isInteger(model.value) ? "int" : "double";
+			default: throw Error("Unsupported literal value");
+		}
+		default: return packageName + "." + model.id;
+	}
+}
+async function formatJava(code) {
+	try {
+		return await format(code, {
+			parser: "java",
+			plugins: [PrettierJavaPlugin]
+		});
+	} catch (error) {
+		console.error(error);
+		return code;
+	}
+}
+async function generateJavaCodes(options) {
+	const { package: packageName, srcDir, routes = [], models = [] } = options;
+	const codes = /* @__PURE__ */ new Map();
+	const namedModels = collectModelFromRoutes(routes);
+	for (const model of models) for (const [id, subModel] of collectModelDeep(model)) namedModels.set(id, subModel);
+	for (const [id, model] of namedModels) {
+		if (model.kind !== "union" && model.kind !== "record" && model.kind !== "enums" && model.kind !== "error") continue;
+		const path = resolve(srcDir, ...(packageName + "." + id).split("."), ".java");
+		const code = await formatJava(generateJavaClass({
+			package: packageName,
+			model
+		}));
+		codes.set(path, code);
+	}
+	return codes.entries().map(([path, code]) => ({
+		path,
+		code
+	})).toArray();
+}
+//#endregion
+//#region src/generator/rust.ts
+function generateRustCode(options) {
+	const { model } = options;
+	switch (model.kind) {
+		case "record": return generateRecordCode(model);
+		case "union": return generateUnionCode(model);
+		case "error": return generateErrorCode(model);
+		case "enums": return generateEnumCode(model);
+	}
+}
+function generateRecordCode(model) {
+	const structName = toPascalCase(model.id || "Unknown");
+	const structFields = Object.entries(model.properties).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generateStructField(k, v));
+	const constFields = Object.entries(model.properties).filter(([_, v]) => v.kind === "literal").map(([k, v]) => generateConstField(k, v));
+	const hasConstants = constFields.length > 0;
+	const hasFields = structFields.length > 0;
+	let code = `use serde::Serialize;\n\n`;
+	if (hasConstants && hasFields) {
+		code += `#[derive(Serialize)]\npub struct ${structName} {\n`;
+		structFields.forEach((f) => {
+			code += `    ${f};\n`;
+		});
+		code += `}\n\n`;
+		code += `impl ${structName} {\n`;
+		code += `    pub const CODE: &'static str = "${model.id}";\n`;
+		constFields.forEach((f) => {
+			code += `    pub ${f};\n`;
+		});
+		code += `}\n`;
+	} else if (hasFields) {
+		code += `#[derive(Serialize)]\npub struct ${structName} {\n`;
+		structFields.forEach((f) => {
+			code += `    ${f};\n`;
+		});
+		code += `}\n`;
+	} else if (hasConstants) {
+		code += `#[derive(Serialize)]\npub struct ${structName};\n\n`;
+		code += `impl ${structName} {\n`;
+		code += `    pub const CODE: &'static str = "${model.id}";\n`;
+		constFields.forEach((f) => {
+			code += `    pub ${f};\n`;
+		});
+		code += `}\n`;
+	}
+	return code;
+}
+function generateUnionCode(model) {
+	const enumName = toPascalCase(model.id || "Unknown");
+	let code = `use serde::Serialize;\n\n`;
+	code += `#[derive(Serialize)]\n#[serde(tag = "type", content = "value")]\npub enum ${enumName} {\n`;
+	Object.entries(model.variants).forEach(([k, v]) => {
+		const variantName = toPascalCase(k);
+		if (v.kind === "literal") code += `    ${variantName},\n`;
+		else {
+			const variantType = generateModelSignature(v);
+			code += `    ${variantName}(${variantType}),\n`;
+		}
+	});
+	code += `}\n`;
+	return code;
+}
+function generateErrorCode(model) {
+	const structName = toPascalCase(model.id || "Unknown");
+	const contextFields = Object.entries(model.context ?? {}).filter(([_, v]) => v.kind !== "literal").map(([k, v]) => generateStructField(k, v));
+	const constFields = Object.entries(model.context ?? {}).filter(([_, v]) => v.kind === "literal").map(([k, v]) => generateConstField(k, v));
+	let code = `use serde::Serialize;\n\n`;
+	if (contextFields.length > 0 || constFields.length > 0) {
+		code += `#[derive(Serialize)]\npub struct ${structName} {\n`;
+		code += `    pub code: &'static str,\n`;
+		if (contextFields.length > 0) code += `    pub context: ${structName}Context,\n`;
+		code += `}\n\n`;
+		if (contextFields.length > 0) {
+			code += `#[derive(Serialize)]\npub struct ${structName}Context {\n`;
+			contextFields.forEach((f) => {
+				code += `    ${f};\n`;
+			});
+			code += `}\n\n`;
+		}
+		code += `impl ${structName} {\n`;
+		code += `    pub const CODE: &'static str = "${model.code}";\n`;
+		constFields.forEach((f) => {
+			code += `    pub ${f};\n`;
+		});
+		code += `}\n`;
+	} else {
+		code += `#[derive(Serialize)]\npub struct ${structName} {\n`;
+		code += `    pub code: &'static str,\n`;
+		code += `}\n\n`;
+		code += `impl ${structName} {\n`;
+		code += `    pub const CODE: &'static str = "${model.code}";\n`;
+		code += `}\n`;
+	}
+	return code;
+}
+function generateEnumCode(model) {
+	const enumName = toPascalCase(model.id || "Unknown");
+	let code = `use serde::Serialize;\n\n`;
+	code += `#[derive(Serialize, Debug, Clone, Copy, PartialEq, Eq)]\npub enum ${enumName} {\n`;
+	Object.entries(model.variants).forEach(([k, v]) => {
+		const variantName = toUpperSnakeCase(k);
+		code += `    #[serde(rename = "${v}")]\n`;
+		code += `    ${variantName},\n`;
+	});
+	code += `}\n`;
+	return code;
+}
+function generateStructField(name, property) {
+	return `pub ${toSnakeCase(name)}: ${generateModelSignature(property)}`;
+}
+function generateConstField(name, property) {
+	return `const ${toUpperSnakeCase(name)}: ${generateModelSignature(property)} = ${generateStaticValue(property.value)}`;
+}
+function generateStaticValue(value) {
+	switch (typeof value) {
+		case "string": return `"${value}"`;
+		case "boolean": return String(value);
+		case "number": return Number.isInteger(value) ? String(value) : `${value}.0`;
+		default: throw Error("Unsupported literal value");
+	}
+}
+function generateModelSignature(model) {
+	switch (model.kind) {
+		case "string": return "String";
+		case "int32": return "i32";
+		case "int64": return "i64";
+		case "float32": return "f32";
+		case "float64": return "f64";
+		case "boolean": return "bool";
+		case "date": return "chrono::NaiveDate";
+		case "datetime": return "chrono::DateTime<chrono::Utc>";
+		case "duration": return "serde_json::Value";
+		case "array": return `Vec<${generateModelSignature(model.base)}>`;
+		case "set": return `Vec<${generateModelSignature(model.base)}>`;
+		case "map": return `std::collections::HashMap<String, ${generateModelSignature(model.base)}>`;
+		case "optional": return `Option<${generateModelSignature(model.base)}>`;
+		case "literal": switch (typeof model.value) {
+			case "string": return "&str";
+			case "boolean": return "bool";
+			case "number": return Number.isInteger(model.value) ? "i64" : "f64";
+			default: throw Error("Unsupported literal value");
+		}
+		default: return model.id ? toPascalCase(model.id) : "()";
+	}
+}
+function toPascalCase(str) {
+	return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (_, c) => c ? c.toUpperCase() : "");
+}
+function toSnakeCase(str) {
+	return str.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").replace(/^_/, "").toLowerCase();
+}
+function toUpperSnakeCase(str) {
+	return toSnakeCase(str).toUpperCase();
+}
+async function formatRust(code) {
+	try {
+		return await format(code, {
+			parser: "rust",
+			plugins: [PrettierRustPlugin]
+		});
+	} catch (error) {
+		console.error(error);
+		return code;
+	}
+}
+async function generateRustCodes(options) {
+	const { module_name, srcDir, routes = [], models = [] } = options;
+	const codes = /* @__PURE__ */ new Map();
+	const namedModels = collectModelFromRoutes(routes);
+	for (const model of models) for (const [id, subModel] of collectModelDeep(model)) namedModels.set(id, subModel);
+	for (const [id, model] of namedModels) {
+		if (model.kind !== "union" && model.kind !== "record" && model.kind !== "enums" && model.kind !== "error") continue;
+		const fullname = module_name + "::" + toSnakeCase(id);
+		const path = resolve(srcDir, ...fullname.split("::"), ".rs");
+		const code = await formatRust(generateRustCode({
+			module_name: fullname,
+			model
+		}));
+		codes.set(path, code);
+	}
+	return codes.entries().map(([path, code]) => ({
+		path,
+		code
+	})).toArray();
+}
+//#endregion
+export { array, binary, boolean, collectModelDeep, collectModelFromRoutes, date, datetime, duration, enums, error, float32, float64, form, formatJava, formatRust, generateJavaClass, generateJavaCodes, generateJsonSchema, generateOpenapi, generateRustCode, generateRustCodes, int32, int64, json, jsonStream, literal, map, optional, plainText, plainTextStream, record, route, set, string, union };
+
+//# sourceMappingURL=index.mjs.map