@lovrozagar/honey 0.6.5 → 0.7.0

package/src/codegen-sanitize.ts

@@ -31,10 +31,6 @@ export function sanitizeZodJsonSchema(obj: Record<string, unknown>): Record<stri
 	const out: Record<string, unknown> = {}
 	for (const [key, val] of Object.entries(obj)) {
 		if (key === "$schema" || key === "~standard") continue
-		if (key === "anyOf" && Array.isArray(val)) {
-			out.oneOf = val.map((item) => sanitizeSchemaValue(item))
-			continue
-		}
 		if (SCHEMA_MAP_KEYS.has(key) && asRecord(val)) {
 			const mapped: Record<string, unknown> = {}
 			for (const [childKey, child] of Object.entries(val)) {

package/src/codegen-schema-naming.ts

@@ -13,10 +13,23 @@ export function shortHash(canonical: string): string {
 	return hashString(canonical).slice(0, 6)
 }
 
+/** `user-profiles`, `user_profiles`, `books:archive`, `v1.json` → one PascalCase word, letters and digits only. */
 function toPascal(segment: string): string {
 	return segment
-		.replace(/[-_](.)/g, (_, c: string) => c.toUpperCase())
-		.replace(/^(.)/, (_, c: string) => c.toUpperCase())
+		.split(/[^A-Za-z0-9]+/)
+		.filter((part) => part.length > 0)
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join("")
+}
+
+/**
+ * A name OpenAPI accepts as a `components.schemas` key (`^[a-zA-Z0-9._-]+$`) that also reads
+ * as an identifier in every SDK language: letters, digits and `_`, never a leading digit.
+ */
+export function sanitizeComponentName(name: string): string {
+	const cleaned = name.replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "")
+	if (cleaned === "") return ""
+	return /^[0-9]/.test(cleaned) ? `S${cleaned}` : cleaned
 }
 
 function stripPathPrefix(path: string): string[] {
@@ -128,12 +141,12 @@ export function deriveErrorEnvelopeName(schema: Record<string, unknown>, fallbac
 	const keysPascal = keys
 		.map((k) =>
 			k
-				.split(/[_-]/)
+				.split(/[^A-Za-z0-9]+/)
 				.map((w) => w.charAt(0).toUpperCase() + w.slice(1))
 				.join(""),
 		)
 		.join("")
-	return `Err${status}${keysPascal}`
+	return sanitizeComponentName(`Err${status}${keysPascal}`)
 }
 
 /** Derives a human-readable schema component name from operation context. */
@@ -145,8 +158,8 @@ export function deriveSchemaName(ctx: SchemaNameContext): string {
 
 	if (ctx.fieldPath && ctx.fieldPath.length > 0) {
 		const fieldPart = ctx.fieldPath.map(toPascal).join("")
-		return `${base}${fieldPart}`
+		return sanitizeComponentName(`${base}${fieldPart}`)
 	}
 
-	return `${base}${roleSuffix(ctx)}`
+	return sanitizeComponentName(`${base}${roleSuffix(ctx)}`)
 }

package/src/codegen-sdk-model.ts

@@ -0,0 +1,228 @@
+/* One request model for the Go, Rust, Python and Go CLI emitters, built from the IR alone.
+ *
+ * Regular, SSE, WebSocket and realtime operations share it, so method, query, headers, body and
+ * response handling are decided once here instead of per emitter from the raw spec.
+ */
+
+import type { OpenApiSpecInput } from "./codegen.ts"
+import { irResolver, parseOpenApiPath, toIR } from "./codegen-ir.ts"
+import type { IR, IRMultipartPart, IROperation, IRParam, IRPathSegment, IRSchema } from "./codegen-ir.ts"
+import { cmpCodeUnit } from "./codegen-lang.ts"
+
+export type SdkBody =
+	| { kind: "json"; contentType: string; schema: IRSchema; required: boolean }
+	| { kind: "form"; contentType: string; schema: IRSchema; required: boolean }
+	| { kind: "multipart"; contentType: string; parts: IRMultipartPart[]; required: boolean }
+	| { kind: "binary"; contentType: string; required: boolean }
+	| { kind: "text"; contentType: string; required: boolean }
+
+export type SdkResponseKind = "json" | "text" | "binary" | "none"
+
+export type SdkSuccess = {
+	kind: SdkResponseKind
+	status: string
+	contentType?: string
+	schema?: IRSchema
+}
+
+export type SdkStream = "sse" | "ws" | "realtime" | null
+
+export type SdkOp = {
+	ir: IROperation
+	id: string
+	segments: string[]
+	method: string
+	path: string
+	pathSegments: IRPathSegment[]
+	pathParams: IRParam[]
+	/** Query params, code-unit sorted by name. */
+	query: IRParam[]
+	headers: IRParam[]
+	body?: SdkBody
+	success: SdkSuccess
+	errorStatuses: number[]
+	stream: SdkStream
+	idempotent: boolean
+	invalidates: string[]
+	summary: string
+	description: string
+	deprecated: boolean
+}
+
+export type SdkModel = {
+	ir: IR
+	ops: SdkOp[]
+	opsById: Map<string, SdkOp>
+	/** Schema names in code-unit order. */
+	schemaNames: string[]
+	/** Follows `ref` nodes to the component schema; unknown refs resolve to `unknown`. */
+	resolve: (schema: IRSchema) => IRSchema
+}
+
+export function mediaEssence(contentType: string): string {
+	return contentType.split(";")[0]?.trim().toLowerCase() ?? ""
+}
+
+export function isJsonMedia(contentType: string): boolean {
+	const e = mediaEssence(contentType)
+	return e === "application/json" || e.endsWith("+json")
+}
+
+export function isTextMedia(contentType: string): boolean {
+	const e = mediaEssence(contentType)
+	return e.startsWith("text/") || e === "application/xml" || e.endsWith("+xml")
+}
+
+function classifyResponse(contentType: string | undefined): SdkResponseKind {
+	if (!contentType) return "none"
+	if (isJsonMedia(contentType)) return "json"
+	if (mediaEssence(contentType) === "text/event-stream") return "none"
+	if (isTextMedia(contentType)) return "text"
+	return "binary"
+}
+
+function successOf(op: IROperation): SdkSuccess {
+	const codes = Object.keys(op.responses)
+		.map((s) => ({ code: Number.parseInt(s, 10), status: s }))
+		.filter((x) => /^[0-9]{3}$/.test(x.status) && x.code >= 200 && x.code < 300)
+		.sort((a, b) => a.code - b.code)
+	const preferred = codes.find((c) => op.responses[c.status]?.contentType !== undefined) ?? codes[0]
+	if (!preferred) {
+		/* only `default` or 2XX ranges: treat as JSON when they carry JSON, else unknown */
+		const fallback = op.responses["2XX"] ?? op.responses.default
+		if (fallback?.contentType && isJsonMedia(fallback.contentType)) {
+			const out: SdkSuccess = { contentType: fallback.contentType, kind: "json", status: fallback.status }
+			if (fallback.schema) out.schema = fallback.schema
+			return out
+		}
+		return { kind: Object.keys(op.responses).length === 0 ? "json" : "none", status: "200" }
+	}
+	const resp = op.responses[preferred.status]
+	const kind = preferred.code === 204 || preferred.code === 205 ? "none" : classifyResponse(resp?.contentType)
+	const out: SdkSuccess = { kind, status: preferred.status }
+	if (resp?.contentType) out.contentType = resp.contentType
+	if (resp?.schema && kind === "json") out.schema = resp.schema
+	return out
+}
+
+function bodyOf(op: IROperation, resolve: (s: IRSchema) => IRSchema): SdkBody | undefined {
+	const b = op.body
+	if (!b) return undefined
+	if (b.kind === "stream") return { contentType: b.contentType, kind: "binary", required: b.required }
+	if (b.kind === "multipart") {
+		return { contentType: b.contentType, kind: "multipart", parts: b.parts, required: b.required }
+	}
+	const essence = mediaEssence(b.contentType)
+	if (isJsonMedia(b.contentType)) {
+		return { contentType: b.contentType, kind: "json", required: b.required, schema: b.schema }
+	}
+	if (essence === "application/x-www-form-urlencoded") {
+		return { contentType: b.contentType, kind: "form", required: b.required, schema: b.schema }
+	}
+	if (essence === "multipart/form-data") {
+		/* text-only multipart: every property is a text part */
+		const resolved = resolve(b.schema)
+		const parts: IRMultipartPart[] =
+			resolved.kind === "object" ? resolved.fields.map((f) => ({ name: f.name, schema: f.schema, type: "text" })) : []
+		return { contentType: b.contentType, kind: "multipart", parts, required: b.required }
+	}
+	if (isTextMedia(b.contentType)) return { contentType: b.contentType, kind: "text", required: b.required }
+	return { contentType: b.contentType, kind: "binary", required: b.required }
+}
+
+export function buildSdkModel(spec: OpenApiSpecInput): SdkModel {
+	const ir = toIR(spec, { deriveOperationIds: true })
+
+	const resolve = irResolver(ir.schemas)
+
+	const ops: SdkOp[] = []
+	const opsById = new Map<string, SdkOp>()
+	for (const op of ir.operations) {
+		const ext = op.extensions
+		let stream: SdkStream = null
+		if (ext.realtime) stream = "realtime"
+		else if (ext.websocket) stream = "ws"
+		else if (ext.sse) stream = "sse"
+
+		const errorStatuses = Object.keys(op.responses)
+			.filter((s) => /^[0-9]{3}$/.test(s))
+			.map(Number)
+			.filter((n) => n >= 400)
+			.sort((a, b) => a - b)
+
+		const sdkOp: SdkOp = {
+			body: bodyOf(op, resolve),
+			deprecated: ext.deprecated === true,
+			description: op.description ?? "",
+			errorStatuses,
+			headers: op.params.header,
+			id: op.id,
+			idempotent: ext.idempotencyKey === true,
+			invalidates: ext.invalidates ?? [],
+			ir: op,
+			method: op.method,
+			path: op.path,
+			pathParams: op.params.path,
+			pathSegments: parseOpenApiPath(op.path),
+			query: [...op.params.query].sort((a, b) => cmpCodeUnit(a.name, b.name)),
+			segments: op.id.split("."),
+			stream,
+			success: successOf(op),
+			summary: op.summary ?? "",
+		}
+		ops.push(sdkOp)
+		opsById.set(op.id, sdkOp)
+	}
+
+	const schemaNames = Object.keys(ir.schemas).sort(cmpCodeUnit)
+	return { ir, ops, opsById, resolve, schemaNames }
+}
+
+/** Refs a schema reaches by value: through fields, allOf, nullable and union variants, not through containers. */
+function valueRefs(schema: IRSchema, out: Set<string>): void {
+	switch (schema.kind) {
+		case "ref":
+			out.add(schema.name)
+			return
+		case "object":
+			for (const f of schema.fields) valueRefs(f.schema, out)
+			return
+		case "allOf":
+			for (const p of schema.parts) valueRefs(p, out)
+			return
+		case "nullable":
+			valueRefs(schema.inner, out)
+			return
+		case "union":
+			for (const v of schema.variants) valueRefs(v, out)
+			return
+		default:
+			return
+	}
+}
+
+/** Component schemas on a by-value reference cycle (direct or mutual). Such references need a pointer or `Box`. */
+export function valueCycleSchemas(schemas: Record<string, IRSchema>): Set<string> {
+	const edges = new Map<string, Set<string>>()
+	for (const [name, schema] of Object.entries(schemas)) {
+		const refs = new Set<string>()
+		valueRefs(schema, refs)
+		edges.set(name, refs)
+	}
+	const cyclic = new Set<string>()
+	for (const start of edges.keys()) {
+		const seen = new Set<string>()
+		const stack = [...(edges.get(start) ?? [])]
+		while (stack.length > 0) {
+			const cur = stack.pop() as string
+			if (cur === start) {
+				cyclic.add(start)
+				break
+			}
+			if (seen.has(cur)) continue
+			seen.add(cur)
+			for (const next of edges.get(cur) ?? []) stack.push(next)
+		}
+	}
+	return cyclic
+}