@lovrozagar/honey 0.7.3 → 1.0.0-rc.3

package/src/codegen-lang.ts

@@ -1,517 +0,0 @@
-/* Per-language naming and literal writers shared by the Go, Rust, Python and Go CLI emitters.
- *
- * Every identifier an emitter derives from spec text (operationIds, schema names, field keys,
- * param names, enum values) goes through a sanitizer here, and every spec string that lands in
- * source (string literals, comments, doc comments, struct tags) goes through a writer here. The
- * emitters never interpolate raw spec text into source.
- */
-
-/** Code-unit ordering. `localeCompare` depends on the host locale and makes output differ across machines. */
-export function cmpCodeUnit(a: string, b: string): number {
-	return a < b ? -1 : a > b ? 1 : 0
-}
-
-export function sortedEntries<V>(record: Record<string, V>): Array<[string, V]> {
-	return Object.entries(record).sort(([a], [b]) => cmpCodeUnit(a, b))
-}
-
-/** Splits arbitrary text into ASCII alphanumeric words: `user-id` / `user_id` / `userId` → [user, id]. */
-export function words(raw: string): string[] {
-	return raw
-		.replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-		.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
-		.split(/[^A-Za-z0-9]+/)
-		.filter((w) => w.length > 0)
-}
-
-/** Words joined PascalCase, keeping each word's inner case: `user-id` → `UserId`, `getHTTP` → `GetHTTP`. */
-export function pascalWords(raw: string): string {
-	return words(raw)
-		.map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-		.join("")
-}
-
-export function snakeWords(raw: string): string {
-	return words(raw)
-		.map((w) => w.toLowerCase())
-		.join("_")
-}
-
-export function camelWords(raw: string): string {
-	const p = pascalWords(raw)
-	return p.charAt(0).toLowerCase() + p.slice(1)
-}
-
-/** Hands out unique names in one scope. Collisions get a stable numeric suffix in claim order. */
-export class NameScope {
-	readonly #taken = new Set<string>()
-	readonly #fold: (name: string) => string
-
-	constructor(reserved: Iterable<string> = [], fold: (name: string) => string = (n) => n) {
-		this.#fold = fold
-		for (const r of reserved) this.#taken.add(fold(r))
-	}
-
-	has(name: string): boolean {
-		return this.#taken.has(this.#fold(name))
-	}
-
-	reserve(name: string): void {
-		this.#taken.add(this.#fold(name))
-	}
-
-	claim(base: string): string {
-		let name = base
-		for (let i = 2; this.#taken.has(this.#fold(name)); i++) name = `${base}${i}`
-		this.#taken.add(this.#fold(name))
-		return name
-	}
-}
-
-/** Memoized `NameScope`: the same raw key always maps to the same claimed name. */
-export class NameTable {
-	readonly #scope: NameScope
-	readonly #byKey = new Map<string, string>()
-
-	constructor(reserved: Iterable<string> = [], fold?: (name: string) => string) {
-		this.#scope = new NameScope(reserved, fold)
-	}
-
-	get(key: string, base: string): string {
-		const hit = this.#byKey.get(key)
-		if (hit !== undefined) return hit
-		const name = this.#scope.claim(base)
-		this.#byKey.set(key, name)
-		return name
-	}
-}
-
-function splitLines(text: string): string[] {
-	return text.split(/\r\n|\r|\n|\u2028|\u2029|\u0085/)
-}
-
-/** Replaces unpaired UTF-16 surrogates; no target language can encode them in source. */
-function wellFormed(s: string): string {
-	return s.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD")
-}
-
-function hex(n: number, width: number): string {
-	return n.toString(16).padStart(width, "0")
-}
-
-/**
- * Text for a comment or docstring: well-formed, with every character a compiler rejects even inside
- * a comment (Go and Python refuse NUL; Go refuses a BOM) written as visible `\uXXXX` text. Tab and
- * line breaks stay; the writers split lines themselves.
- */
-function commentText(s: string): string {
-	let out = ""
-	for (const ch of wellFormed(s)) {
-		const c = ch.codePointAt(0) ?? 0
-		const lineOrTab = c === 0x09 || c === 0x0a || c === 0x0d
-		out += (c < 0x20 && !lineOrTab) || c === 0x7f || c === 0xfeff ? `\\u${hex(c, 4)}` : ch
-	}
-	return out
-}
-
-/* ── Go ── */
-
-export const GO_KEYWORDS = new Set([
-	"break",
-	"case",
-	"chan",
-	"const",
-	"continue",
-	"default",
-	"defer",
-	"else",
-	"fallthrough",
-	"for",
-	"func",
-	"go",
-	"goto",
-	"if",
-	"import",
-	"interface",
-	"map",
-	"package",
-	"range",
-	"return",
-	"select",
-	"struct",
-	"switch",
-	"type",
-	"var",
-])
-
-/** Predeclared identifiers plus the stdlib package names generated files import. */
-export const GO_PREDECLARED = new Set([
-	"any",
-	"append",
-	"bool",
-	"byte",
-	"cap",
-	"clear",
-	"close",
-	"comparable",
-	"complex",
-	"complex128",
-	"complex64",
-	"copy",
-	"delete",
-	"error",
-	"false",
-	"float32",
-	"float64",
-	"imag",
-	"int",
-	"int16",
-	"int32",
-	"int64",
-	"int8",
-	"iota",
-	"len",
-	"make",
-	"max",
-	"min",
-	"new",
-	"nil",
-	"panic",
-	"print",
-	"println",
-	"real",
-	"recover",
-	"rune",
-	"string",
-	"true",
-	"uint",
-	"uint16",
-	"uint32",
-	"uint64",
-	"uint8",
-	"uintptr",
-	/* imported packages */
-	"bytes",
-	"context",
-	"errors",
-	"fmt",
-	"http",
-	"io",
-	"iter",
-	"json",
-	"multipart",
-	"os",
-	"slices",
-	"strconv",
-	"strings",
-	"sync",
-	"textproto",
-	"time",
-	"url",
-	"websocket",
-	"cobra",
-	"cli",
-	"sdk",
-])
-
-/** Exported Go identifier: `user-id` → `UserId`, `2fa` → `N2fa`, `` → `X`. */
-export function goExported(raw: string): string {
-	const p = pascalWords(raw)
-	if (p === "") return "X"
-	if (/^[0-9]/.test(p)) return `N${p}`
-	return p
-}
-
-/** Unexported Go identifier (locals, params). Keywords, predeclared names and imports get a `_` suffix. */
-export function goLocal(raw: string): string {
-	let c = camelWords(raw)
-	if (c === "") c = "v"
-	if (/^[0-9]/.test(c)) c = `n${c}`
-	if (GO_KEYWORDS.has(c) || GO_PREDECLARED.has(c)) return `${c}_`
-	return c
-}
-
-/** Go interpreted string literal. */
-export function goString(s: string): string {
-	let out = '"'
-	for (const ch of wellFormed(s)) {
-		const c = ch.codePointAt(0) ?? 0
-		if (ch === "\\") out += "\\\\"
-		else if (ch === '"') out += '\\"'
-		else if (ch === "\n") out += "\\n"
-		else if (ch === "\r") out += "\\r"
-		else if (ch === "\t") out += "\\t"
-		else if (c < 0x20 || c === 0x7f) out += `\\x${hex(c, 2)}`
-		else if (c === 0xfeff) out += "\\ufeff"
-		else out += ch
-	}
-	return `${out}"`
-}
-
-/** `// ` comment lines for arbitrary text; every line break in the input starts a new comment line. */
-export function goComment(text: string, indent = ""): string[] {
-	return splitLines(commentText(text)).map((line) => (line.trim() === "" ? `${indent}//` : `${indent}// ${line}`))
-}
-
-/** encoding/json silently ignores tag names with other characters and falls back to the field name. */
-export function goJsonTagNameValid(key: string): boolean {
-	if (key === "") return false
-	for (const ch of key) {
-		if ("!#$%&()*+-./:;<=>?@[]^_{|}~ ".includes(ch)) continue
-		if (!/[\p{L}\p{N}]/u.test(ch)) return false
-	}
-	return true
-}
-
-/** A Go struct tag carrying a json tag. The tag is an interpreted string so any key text is representable. */
-export function goJsonTag(key: string, omit: boolean | "omitzero"): string {
-	const value = omit === "omitzero" ? `${key},omitzero` : omit ? `${key},omitempty` : key
-	const inner = `json:${goString(value)}`
-	/* raw-string form when it round-trips: keeps the common case readable */
-	if (!inner.includes("`")) return `\`${inner}\``
-	return goString(inner)
-}
-
-/* ── Rust ── */
-
-export const RUST_KEYWORDS = new Set([
-	"as",
-	"break",
-	"const",
-	"continue",
-	"crate",
-	"else",
-	"enum",
-	"extern",
-	"false",
-	"fn",
-	"for",
-	"if",
-	"impl",
-	"in",
-	"let",
-	"loop",
-	"match",
-	"mod",
-	"move",
-	"mut",
-	"pub",
-	"ref",
-	"return",
-	"self",
-	"Self",
-	"static",
-	"struct",
-	"super",
-	"trait",
-	"true",
-	"type",
-	"unsafe",
-	"use",
-	"where",
-	"while",
-	"async",
-	"await",
-	"dyn",
-	"abstract",
-	"become",
-	"box",
-	"do",
-	"final",
-	"macro",
-	"override",
-	"priv",
-	"typeof",
-	"unsized",
-	"virtual",
-	"yield",
-	"try",
-	"gen",
-])
-
-/** Keywords that cannot be raw identifiers (`r#self` is invalid). */
-const RUST_NON_RAW = new Set(["crate", "self", "Self", "super", "extern", "_"])
-
-/** Prelude and std names a generated type must not shadow. */
-export const RUST_PRELUDE_TYPES = new Set([
-	"Box",
-	"Clone",
-	"Copy",
-	"Default",
-	"Drop",
-	"Eq",
-	"Err",
-	"Fn",
-	"From",
-	"HashMap",
-	"Into",
-	"Iterator",
-	"None",
-	"Ok",
-	"Option",
-	"Ord",
-	"PartialEq",
-	"PartialOrd",
-	"Result",
-	"Send",
-	"Sized",
-	"Some",
-	"String",
-	"Sync",
-	"ToOwned",
-	"ToString",
-	"Vec",
-	"Deserialize",
-	"Serialize",
-	"Deserialize_repr",
-	"Serialize_repr",
-	"Stream",
-	"Arc",
-])
-
-/** snake_case Rust value identifier (fields, params, fns). Keywords become raw identifiers when allowed. */
-export function rustValueIdent(raw: string): string {
-	let s = snakeWords(raw)
-	if (s === "") s = "value"
-	if (/^[0-9]/.test(s)) s = `_${s}`
-	if (RUST_KEYWORDS.has(s)) return RUST_NON_RAW.has(s) ? `${s}_` : `r#${s}`
-	return s
-}
-
-/** Same as `rustValueIdent` but never a raw identifier: for names joined into other names. */
-export function rustPlainSnake(raw: string): string {
-	let s = snakeWords(raw)
-	if (s === "") s = "value"
-	if (/^[0-9]/.test(s)) s = `_${s}`
-	if (RUST_KEYWORDS.has(s)) return `${s}_`
-	return s
-}
-
-/** PascalCase Rust type/variant identifier. */
-export function rustTypeIdent(raw: string): string {
-	let p = pascalWords(raw)
-	if (p === "") p = "Value"
-	if (/^[0-9]/.test(p)) p = `N${p}`
-	if (p === "Self") return "Self_"
-	return p
-}
-
-/** Rust string literal. `JSON.stringify` is not one: rustc rejects `\b`, `\f` and `\uXXXX`. */
-export function rustString(s: string): string {
-	let out = '"'
-	for (const ch of wellFormed(s)) {
-		const c = ch.codePointAt(0) ?? 0
-		if (ch === "\\") out += "\\\\"
-		else if (ch === '"') out += '\\"'
-		else if (ch === "\n") out += "\\n"
-		else if (ch === "\r") out += "\\r"
-		else if (ch === "\t") out += "\\t"
-		else if (ch === "\0") out += "\\0"
-		else if (c < 0x20 || c === 0x7f || c === 0xfeff) out += `\\u{${hex(c, 2)}}`
-		else out += ch
-	}
-	return `${out}"`
-}
-
-/** `/// ` doc lines; each input line break starts a new doc line so text never becomes code. */
-export function rustDoc(text: string, indent = ""): string[] {
-	return splitLines(commentText(text)).map((line) => (line.trim() === "" ? `${indent}///` : `${indent}/// ${line}`))
-}
-
-/** Text safe inside a `/* … *\/` block comment. */
-export function blockCommentText(text: string): string {
-	return commentText(text).replace(/\*\//g, "* /").replace(/\/\*/g, "/ *")
-}
-
-/* ── Python ── */
-
-export const PY_KEYWORDS = new Set([
-	"False",
-	"None",
-	"True",
-	"and",
-	"as",
-	"assert",
-	"async",
-	"await",
-	"break",
-	"class",
-	"continue",
-	"def",
-	"del",
-	"elif",
-	"else",
-	"except",
-	"finally",
-	"for",
-	"from",
-	"global",
-	"if",
-	"import",
-	"in",
-	"is",
-	"lambda",
-	"nonlocal",
-	"not",
-	"or",
-	"pass",
-	"raise",
-	"return",
-	"try",
-	"while",
-	"with",
-	"yield",
-	/* soft keywords and names generated code relies on */
-	"match",
-	"case",
-	"type",
-	"_",
-	"self",
-	"cls",
-])
-
-/** snake_case Python identifier. Keywords and reserved names get a `_` suffix (PEP 8). */
-export function pyIdentifier(raw: string): string {
-	let s = snakeWords(raw)
-	if (s === "") s = "value"
-	if (/^[0-9]/.test(s)) s = `_${s}`
-	if (PY_KEYWORDS.has(s)) return `${s}_`
-	return s
-}
-
-/** PascalCase Python class name. */
-export function pyClassName(raw: string): string {
-	let p = pascalWords(raw)
-	if (p === "") p = "Model"
-	if (/^[0-9]/.test(p)) p = `N${p}`
-	if (PY_KEYWORDS.has(p)) p = `${p}_`
-	return p
-}
-
-/** Python string literal (double-quoted, escapes everything non-printable). */
-export function pyString(s: string): string {
-	let out = '"'
-	for (const ch of s) {
-		const c = ch.codePointAt(0) ?? 0
-		if (ch === "\\") out += "\\\\"
-		else if (ch === '"') out += '\\"'
-		else if (ch === "\n") out += "\\n"
-		else if (ch === "\r") out += "\\r"
-		else if (ch === "\t") out += "\\t"
-		else if (c < 0x20 || c === 0x7f) out += `\\x${hex(c, 2)}`
-		else if (c >= 0xd800 && c <= 0xdfff) out += `\\u${hex(c, 4)}`
-		else if (c === 0x2028 || c === 0x2029 || c === 0x85 || c === 0xfeff) out += `\\u${hex(c, 4)}`
-		else out += ch
-	}
-	return `${out}"`
-}
-
-/** Docstring body lines: backslashes and quotes escaped, so `"""`, a trailing `"` and `C:\users` are inert. */
-export function pyDocLines(text: string): string[] {
-	return splitLines(commentText(text)).map((line) => line.replace(/\\/g, "\\\\").replace(/"/g, '\\"'))
-}
-
-/** `# ` comment lines. */
-export function pyComment(text: string, indent = ""): string[] {
-	return splitLines(commentText(text)).map((line) => (line.trim() === "" ? `${indent}#` : `${indent}# ${line}`))
-}

package/src/codegen-load.ts

@@ -1,150 +0,0 @@
-/** Loads user modules (Vite config, app, merge tree) for codegen. Not a package export. */
-import { existsSync, readFileSync } from "node:fs"
-import { dirname, join, resolve } from "node:path"
-import { fileURLToPath } from "node:url"
-import type { HoneyVitePluginConfig } from "./plugin.ts"
-import { isCodegenProcess, setCodegenProcess } from "./serve-slot.ts"
-
-export type ModuleLoader = (path: string) => Promise<Record<string, unknown>>
-
-const isBun = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined"
-
-/** True when this module runs from `src/*.ts` rather than the compiled `dist/*.js`. */
-export const runningFromSource = import.meta.url.endsWith(".ts")
-
-/**
- * Creates a loader for one generation. Each path is evaluated at most once per loader, so the app
- * is not executed twice. `fresh` drops jiti's module cache between loaders — needed when the
- * process outlives one generation (the Vite plugin without a config file). A process that runs a
- * single generation (the CLI) keeps the cache so shared modules load once.
- *
- * While a module evaluates, `app.serve()` resolves without binding a port.
- */
-export async function createModuleLoader(options: { fresh: boolean; from: string }): Promise<ModuleLoader> {
-	const { createJiti } = await import("jiti")
-	const jiti = createJiti(options.from, {
-		alias: sourceAliases(),
-		fsCache: false,
-		interopDefault: true,
-		moduleCache: !options.fresh,
-	})
-	const loaded = new Map<string, Promise<Record<string, unknown>>>()
-	return (path) => {
-		const abs = resolve(path)
-		let mod = loaded.get(abs)
-		if (!mod) {
-			mod = withCodegenFlag(() => jiti.import(abs) as Promise<Record<string, unknown>>)
-			loaded.set(abs, mod)
-		}
-		return mod
-	}
-}
-
-let evaluating = 0
-let flagWasSet = false
-
-/* overlapping loads share one flag; a flag the caller set for the whole process stays set */
-async function withCodegenFlag<T>(run: () => Promise<T>): Promise<T> {
-	if (evaluating++ === 0) {
-		flagWasSet = isCodegenProcess()
-		setCodegenProcess(true)
-	}
-	try {
-		return await run()
-	} finally {
-		if (--evaluating === 0 && !flagWasSet) setCodegenProcess(false)
-	}
-}
-
-/**
- * When honey runs from source under Node (inside this repository), the app's imports of the
- * package must reach the same source, not a `dist/` that may be missing or stale. Bun resolves the
- * `bun` export condition to source on its own; a compiled install needs no alias.
- */
-function sourceAliases(): Record<string, string> | undefined {
-	if (!runningFromSource || isBun) return undefined
-	const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..")
-	const pkgPath = join(pkgRoot, "package.json")
-	if (!existsSync(pkgPath)) return undefined
-	const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as {
-		exports?: Record<string, { "honey-source"?: string }>
-		name?: string
-	}
-	if (!pkg.name || !pkg.exports) return undefined
-	const aliases: Record<string, string> = {}
-	for (const [subpath, target] of Object.entries(pkg.exports)) {
-		const source = target["honey-source"]
-		if (!source) continue
-		aliases[pkg.name + subpath.slice(1)] = join(pkgRoot, source)
-	}
-	return aliases
-}
-
-/* ---- Vite config ---- */
-
-export const VITE_CONFIG_FILES = [
-	"vite.config.ts",
-	"vite.config.mts",
-	"vite.config.cts",
-	"vite.config.js",
-	"vite.config.mjs",
-	"vite.config.cjs",
-]
-
-export function findViteConfig(cwd: string): string | undefined {
-	for (const name of VITE_CONFIG_FILES) {
-		const path = join(cwd, name)
-		if (existsSync(path)) return path
-	}
-	return undefined
-}
-
-export type ViteConfigEnv = { command: "build" | "serve"; mode: string }
-
-/**
- * Every `honey()` plugin config in a Vite config file, in plugin order. Function-form configs are
- * called with `env`; nested and promised plugin arrays are flattened like Vite does. The config is
- * read off the plugin object, so it works across module instances and runtimes.
- */
-export async function loadHoneyPluginConfigs(
-	configPath: string,
-	load: ModuleLoader,
-	env: ViteConfigEnv,
-): Promise<HoneyVitePluginConfig[]> {
-	const mod = await load(configPath)
-	let config: unknown = "default" in mod ? mod.default : mod
-	if (typeof config === "function") {
-		config = await (config as (env: Record<string, unknown>) => unknown)({
-			command: env.command,
-			isPreview: false,
-			isSsrBuild: false,
-			mode: env.mode,
-		})
-	}
-	config = await config
-	const plugins = await flattenPlugins((config as { plugins?: unknown } | null | undefined)?.plugins)
-	const found: HoneyVitePluginConfig[] = []
-	for (const plugin of plugins) {
-		const honeyConfig = honeyConfigOf(plugin)
-		if (honeyConfig) found.push(honeyConfig)
-	}
-	return found
-}
-
-/** The config a `honey()` plugin object carries, or undefined for any other plugin. */
-export function honeyConfigOf(plugin: unknown): HoneyVitePluginConfig | undefined {
-	if (plugin === null || typeof plugin !== "object") return undefined
-	const p = plugin as { api?: { honeyConfig?: HoneyVitePluginConfig }; name?: unknown }
-	return p.name === "honey" ? p.api?.honeyConfig : undefined
-}
-
-async function flattenPlugins(value: unknown): Promise<unknown[]> {
-	const resolved = await value
-	if (!resolved) return []
-	if (Array.isArray(resolved)) {
-		const out: unknown[] = []
-		for (const item of resolved) out.push(...(await flattenPlugins(item)))
-		return out
-	}
-	return [resolved]
-}

package/src/codegen-loaders.ts

@@ -1,50 +0,0 @@
-/** Dynamic Zod/Effect JSON Schema loaders. Not a package export — tests may import this file. */
-
-export let toJSONSchemaFn: ((schema: unknown, opts?: { io?: "input" | "output" }) => unknown) | undefined
-let toJSONSchemaLoaded = false
-
-export async function loadToJSONSchema(): Promise<
-	((schema: unknown, opts?: { io?: "input" | "output" }) => unknown) | undefined
-> {
-	if (toJSONSchemaLoaded) return toJSONSchemaFn
-	toJSONSchemaLoaded = true
-	try {
-		/* opaque specifier — a plain `const id = "zod"` is constant-folded by rollup/esbuild,
-		   which pulls the whole optional dependency into webworker-target bundles */
-		const zod = await import(["z", "od"].join(""))
-		if (typeof zod.toJSONSchema === "function") {
-			toJSONSchemaFn = zod.toJSONSchema as (schema: unknown, opts?: { io?: "input" | "output" }) => unknown
-		}
-	} catch {
-		/* zod not available */
-	}
-	return toJSONSchemaFn
-}
-
-export let effectJsonSchemaFn: ((schema: unknown) => unknown) | undefined
-let effectLoaded = false
-
-export async function loadEffectJsonSchema(): Promise<((schema: unknown) => unknown) | undefined> {
-	if (effectLoaded) return effectJsonSchemaFn
-	effectLoaded = true
-	try {
-		const effect = await import(["eff", "ect"].join(""))
-		if (effect.JSONSchema && typeof effect.JSONSchema.make === "function") {
-			effectJsonSchemaFn = effect.JSONSchema.make as (schema: unknown) => unknown
-		}
-	} catch {
-		/* effect not available */
-	}
-	return effectJsonSchemaFn
-}
-
-export async function prepareCodegen(): Promise<void> {
-	await Promise.all([loadToJSONSchema(), loadEffectJsonSchema()])
-}
-
-export function resetCodegenJsonSchemaLoadersForTests(): void {
-	toJSONSchemaFn = undefined
-	toJSONSchemaLoaded = true
-	effectJsonSchemaFn = undefined
-	effectLoaded = true
-}