@lovrozagar/honey 0.7.3 → 1.0.0-rc.3

package/src/codegen-sanitize.ts

@@ -1,57 +0,0 @@
-/** OpenAPI cleanup of Zod JSON Schema. Not a package export. */
-
-const SCHEMA_VALUE_KEYS = new Set([
-	"additionalProperties",
-	"contains",
-	"else",
-	"if",
-	"items",
-	"not",
-	"propertyNames",
-	"then",
-	"unevaluatedItems",
-	"unevaluatedProperties",
-])
-
-const SCHEMA_MAP_KEYS = new Set(["$defs", "definitions", "dependentSchemas", "patternProperties", "properties"])
-
-const SCHEMA_ARRAY_KEYS = new Set(["allOf", "anyOf", "oneOf", "prefixItems"])
-
-function asRecord(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object" && !Array.isArray(value)
-}
-
-function sanitizeSchemaValue(value: unknown): unknown {
-	if (typeof value === "boolean") return value
-	if (asRecord(value)) return sanitizeZodJsonSchema(value)
-	return value
-}
-
-export function sanitizeZodJsonSchema(obj: Record<string, unknown>): Record<string, unknown> {
-	const out: Record<string, unknown> = {}
-	for (const [key, val] of Object.entries(obj)) {
-		if (key === "$schema" || key === "~standard") continue
-		if (SCHEMA_MAP_KEYS.has(key) && asRecord(val)) {
-			const mapped: Record<string, unknown> = {}
-			for (const [childKey, child] of Object.entries(val)) {
-				mapped[childKey] = sanitizeSchemaValue(child)
-			}
-			out[key] = mapped
-			continue
-		}
-		if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(val)) {
-			out[key] = val.map((item) => sanitizeSchemaValue(item))
-			continue
-		}
-		if (SCHEMA_VALUE_KEYS.has(key)) {
-			if (key === "items" && Array.isArray(val)) {
-				out[key] = val.map((item) => sanitizeSchemaValue(item))
-			} else {
-				out[key] = sanitizeSchemaValue(val)
-			}
-			continue
-		}
-		out[key] = val
-	}
-	return out
-}

package/src/codegen-schema-naming.ts

@@ -1,165 +0,0 @@
-import { hashString } from "./codegen-hash.ts"
-
-export type SchemaRole = "request" | "response"
-
-export type SchemaNameContext =
-	| { method: string; path: string; role: "request"; fieldPath?: string[] }
-	| { method: string; path: string; role: "response"; status: number; fieldPath?: string[] }
-
-const KNOWN_ACTIONS = new Set(["accept", "cancel", "refresh", "verify", "confirm", "reset", "revoke", "invite"])
-
-/** Returns 6-char lowercase hex derived from content hash. */
-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
-		.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[] {
-	const raw = path.replace(/^\//, "").split("/")
-	/* drop leading version segment like v1, v2, v10 */
-	if (raw.length > 0 && /^v\d+$/.test(raw[0])) raw.shift()
-	return raw
-}
-
-function isParam(segment: string): boolean {
-	return segment.startsWith("{") && segment.endsWith("}")
-}
-
-/*
- * Drop "variant qualifier": when the last raw segment is a non-param non-action
- * literal that follows DIRECTLY after a plural collection noun (no {param} between
- * them), it's a discriminator (e.g. "github"/"stripe" in /webhooks/github).
- * Dropping it ensures both routes derive the same base name so collision detection
- * kicks in and hash-suffix disambiguates their distinct shapes.
- */
-function dropVariantQualifier(rawSegments: string[]): string[] {
-	if (rawSegments.length < 2) return rawSegments
-	const last = rawSegments[rawSegments.length - 1]
-	const prev = rawSegments[rawSegments.length - 2]
-	if (!isParam(last) && !isParam(prev) && !KNOWN_ACTIONS.has(last.toLowerCase())) {
-		const prevPascal = toPascal(prev)
-		/* prev must be a collection noun (ends in 's' after PascalCase) */
-		if (prevPascal.endsWith("s")) {
-			return rawSegments.slice(0, -1)
-		}
-	}
-	return rawSegments
-}
-
-function deriveVerb(method: string, rawSegments: string[]): string {
-	const lastRaw = rawSegments[rawSegments.length - 1]
-
-	if (method === "get") {
-		if (lastRaw && isParam(lastRaw)) return "Get"
-		return "List"
-	}
-	if (method === "patch") return "Update"
-	if (method === "put") return "Replace"
-	if (method === "delete") return "Delete"
-
-	/* POST */
-	if (lastRaw && KNOWN_ACTIONS.has(lastRaw.toLowerCase())) {
-		return toPascal(lastRaw)
-	}
-	return "Create"
-}
-
-function buildResourcePart(rawSegments: string[], verb: string): string {
-	const nonParam = rawSegments.filter((s) => !isParam(s))
-	const lastSeg = rawSegments[rawSegments.length - 1]
-
-	if (lastSeg && KNOWN_ACTIONS.has(lastSeg.toLowerCase()) && verb === toPascal(lastSeg)) {
-		/* last segment is the action verb — drop it; it's already the verb prefix */
-		return nonParam.slice(0, -1).map(toPascal).join("")
-	}
-
-	const parts = nonParam.map(toPascal)
-
-	/* singularize last noun for non-List verbs */
-	if (verb !== "List" && parts.length > 0) {
-		const last = parts[parts.length - 1]
-		if (last.endsWith("s") && last.length > 2) {
-			parts[parts.length - 1] = last.slice(0, -1)
-		}
-	}
-
-	return parts.join("")
-}
-
-function roleSuffix(ctx: SchemaNameContext): string {
-	if (ctx.role === "request") return "Request"
-	return `Response${ctx.status}`
-}
-
-/** Returns true if schema matches anyrow-style error envelope shape. */
-export function isErrorEnvelope(schema: Record<string, unknown>): boolean {
-	if (schema.type !== "object" && !schema.properties) return false
-	const props = schema.properties as Record<string, Record<string, unknown>> | undefined
-	if (!props) return false
-	if (!props.error_key || !props.status || !props.success) return false
-	const successDef = props.success
-	const isFalseConst = successDef.const === false
-	const isFalseEnum = Array.isArray(successDef.enum) && successDef.enum.length === 1 && successDef.enum[0] === false
-	return isFalseConst || isFalseEnum
-}
-
-/** Derives a canonical name for a shared error envelope (e.g. `Err400InvalidInput`). */
-export function deriveErrorEnvelopeName(schema: Record<string, unknown>, fallbackStatus?: number): string {
-	const props = schema.properties as Record<string, Record<string, unknown>>
-	const statusProp = props.status
-	let status: number | undefined
-	if (typeof statusProp.const === "number") status = statusProp.const
-	else if (Array.isArray(statusProp.enum) && statusProp.enum.length === 1 && typeof statusProp.enum[0] === "number")
-		status = statusProp.enum[0]
-	else if (fallbackStatus !== undefined) status = fallbackStatus
-	else throw new Error("deriveErrorEnvelopeName: no status")
-
-	const keyProp = props.error_key
-	const keys: string[] = Array.isArray(keyProp?.enum)
-		? [...keyProp.enum].filter((k): k is string => typeof k === "string").sort()
-		: []
-
-	if (keys.length === 0) return `Err${status}`
-	const keysPascal = keys
-		.map((k) =>
-			k
-				.split(/[^A-Za-z0-9]+/)
-				.map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-				.join(""),
-		)
-		.join("")
-	return sanitizeComponentName(`Err${status}${keysPascal}`)
-}
-
-/** Derives a human-readable schema component name from operation context. */
-export function deriveSchemaName(ctx: SchemaNameContext): string {
-	const rawSegments = dropVariantQualifier(stripPathPrefix(ctx.path))
-	const verb = deriveVerb(ctx.method, rawSegments)
-	const resource = buildResourcePart(rawSegments, verb)
-	const base = `${verb}${resource}`
-
-	if (ctx.fieldPath && ctx.fieldPath.length > 0) {
-		const fieldPart = ctx.fieldPath.map(toPascal).join("")
-		return sanitizeComponentName(`${base}${fieldPart}`)
-	}
-
-	return sanitizeComponentName(`${base}${roleSuffix(ctx)}`)
-}

package/src/codegen-sdk-model.ts

@@ -1,228 +0,0 @@
-/* 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
-}