@ozanarslan/corpus-cli 0.0.1

package/dist/index.mjs

@@ -0,0 +1,595 @@
+import { c as quote, d as toPascalCase, i as logger, m as isAbsent, n as getDefaultConfig, o as StringBuilder, p as cache, v as isSomeArray } from "./getConfig-lU3I2Ejy.mjs";
+import path from "path";
+import fs from "node:fs";
+//#region src/internal/objMerge.ts
+function objMerge(base, override) {
+	if (override === void 0 || override === null) return base;
+	const result = { ...base };
+	for (const key of Object.keys(override)) {
+		const overrideVal = override[key];
+		const baseVal = base[key];
+		if (overrideVal === void 0 || overrideVal === null) continue;
+		if (typeof overrideVal === "object" && !Array.isArray(overrideVal) && typeof baseVal === "object" && !Array.isArray(baseVal) && baseVal !== null) result[key] = objMerge(baseVal, overrideVal);
+		else result[key] = overrideVal;
+	}
+	return result;
+}
+//#endregion
+//#region src/Config/defineConfig.ts
+function defineConfig(config) {
+	return objMerge(getDefaultConfig(), config);
+}
+//#endregion
+//#region src/SchemaPrinter/SchemaPrinterAbstract.ts
+var SchemaPrinterAbstract = class {
+	/**
+	* Split on a depth-0 separator, respecting brackets and quotes.
+	* `<`/`>` are NOT treated as brackets — arktype constraints use them as
+	* comparison operators (`string <= 20`), which would desync the depth counter.
+	*/
+	split(expr, sep) {
+		const parts = [];
+		let depth = 0;
+		let quote = null;
+		let buf = "";
+		for (let i = 0; i < expr.length; i++) {
+			const c = expr[i];
+			if (quote) {
+				buf += c;
+				if (c === quote && expr[i - 1] !== "\\") quote = null;
+				continue;
+			}
+			if (c === "\"" || c === "'") {
+				quote = c;
+				buf += c;
+				continue;
+			}
+			if (c === "{" || c === "(" || c === "[") depth++;
+			else if (c === "}" || c === ")" || c === "]") depth--;
+			if (depth === 0 && c === sep && (sep === "," || sep === ";" || expr[i - 1] === " " && expr[i + 1] === " ")) {
+				parts.push(buf.trim());
+				buf = "";
+				continue;
+			}
+			buf += c;
+		}
+		parts.push(buf.trim());
+		return parts.filter((p) => p.length > 0);
+	}
+	/** Parenthesize a union/intersection so a trailing `[]` binds to the whole thing. */
+	wrap(s) {
+		return this.split(s, "|").length > 1 || this.split(s, "&").length > 1 ? `(${s})` : s;
+	}
+	key(k) {
+		return /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
+	}
+	/** JSON.stringify returns the *value* undefined for undefined — normalize to TS text. */
+	literal(v) {
+		if (v === void 0) return "undefined";
+		if (typeof v === "bigint") return `${v}n`;
+		return JSON.stringify(v) ?? "unknown";
+	}
+	topLevelColon(s) {
+		let depth = 0;
+		let quote = null;
+		for (let i = 0; i < s.length; i++) {
+			const c = s[i];
+			if (quote) {
+				if (c === quote && s[i - 1] !== "\\") quote = null;
+				continue;
+			}
+			if (c === "\"" || c === "'") {
+				quote = c;
+				continue;
+			}
+			if (c === "{" || c === "(" || c === "[") depth++;
+			else if (c === "}" || c === ")" || c === "]") depth--;
+			else if (c === ":" && depth === 0) return i;
+		}
+		return -1;
+	}
+	/** Sort union members: structural types first (alphabetically), then null/undefined last. */
+	sortUnion(members) {
+		const rank = (s) => s === "undefined" ? 2 : s === "null" ? 1 : 0;
+		return [...members].sort((a, b) => rank(a) - rank(b) || a.localeCompare(b));
+	}
+};
+//#endregion
+//#region src/SchemaPrinter/ArkSchemaPrinter.ts
+/** Bare identifiers that are already valid TS. */
+const KEEP = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"boolean",
+	"bigint",
+	"symbol",
+	"Date",
+	"File",
+	"Blob",
+	"FormData",
+	"null",
+	"undefined",
+	"unknown",
+	"never",
+	"object",
+	"Array",
+	"Function"
+]);
+var ArkSchemaPrinter = class extends SchemaPrinterAbstract {
+	print(schema, io) {
+		const t = schema;
+		const side = io === "in" ? t.in : t.out;
+		return this.strip(side.expression);
+	}
+	/**
+	* Rewrite an arktype expression into valid TS: recurse through unions,
+	* intersections and bracketed groups, keeping only TS-valid constituents
+	* and dropping runtime constraints (`string <= 20`, `number % 2`, regexes).
+	*/
+	strip(expr) {
+		const unions = this.split(expr, "|");
+		if (unions.length > 1) return this.sortUnion(unions.map((u) => this.strip(u))).join(" | ");
+		const parts = this.split(expr, "&").map((p) => this.rewriteGroup(p));
+		if (parts.length === 1) return parts[0];
+		const kept = parts.filter((s) => this.isTsToken(s));
+		return kept.length > 0 ? kept.join(" & ") : "unknown";
+	}
+	isTsToken(s) {
+		return KEEP.has(s) || /^".*"$/.test(s) || /^-?[\d.]+n?$/.test(s) || /^(?:true|false)$/.test(s) || /^[({[]/.test(s) || /^Array<[\s\S]*>$/.test(s) || /^[A-Z][\w$]*</.test(s);
+	}
+	/**
+	* Find the index of the bracket that closes the opening bracket at index 0
+	* of `s`, honoring quoted strings and nested brackets of the same kind.
+	* Returns -1 if `s` doesn't start with a bracket or has no matching close.
+	*/
+	findMatchingClose(s) {
+		const open = s[0];
+		if (open !== "{" && open !== "(" && open !== "[") return -1;
+		const close = open === "{" ? "}" : open === "(" ? ")" : "]";
+		let depth = 0;
+		let quote = null;
+		for (let i = 0; i < s.length; i++) {
+			const c = s[i];
+			if (quote) {
+				if (c === quote && s[i - 1] !== "\\") quote = null;
+				continue;
+			}
+			if (c === "\"" || c === "'") {
+				quote = c;
+				continue;
+			}
+			if (c === open) depth++;
+			else if (c === close) {
+				depth--;
+				if (depth === 0) return i;
+			}
+		}
+		return -1;
+	}
+	/** Rewrite an arktype index-signature key like "[string]" into "[key: string]". */
+	rewriteIndexKey(rawKey) {
+		const m = /^\[(.+)\]$/.exec(rawKey);
+		if (!m) return rawKey;
+		return `[key: ${this.strip(m[1])}]`;
+	}
+	/** If `p` is a bracketed group, strip each of its comma-separated members. */
+	rewriteGroup(p) {
+		const closeIdx = this.findMatchingClose(p);
+		if (closeIdx === -1) return p;
+		const open = p[0];
+		const close = p[closeIdx];
+		const inner = p.slice(1, closeIdx);
+		const suffix = p.slice(closeIdx + 1);
+		if (!/^(?:\[\])*$/.test(suffix)) return p;
+		const members = this.split(inner, ",").sort().map((member) => {
+			const idx = this.topLevelColon(member);
+			if (idx === -1) return this.strip(member);
+			const rawKey = member.slice(0, idx).trim();
+			const isIndexKey = /^\[.+\]$/.test(rawKey);
+			return `${isIndexKey ? this.rewriteIndexKey(rawKey) : member.slice(0, idx + 1)}${isIndexKey ? ":" : ""} ${this.strip(member.slice(idx + 1).trim())}`;
+		});
+		const arrayDepth = suffix.length / 2;
+		if (members.length === 0) {
+			const base = `${open}${close}`;
+			return arrayDepth > 0 ? this.wrapArray(base, arrayDepth) : base;
+		}
+		const body = members.join("; ");
+		const base = open === "{" ? `{ ${body} }` : `${open}${body}${close}`;
+		return arrayDepth > 0 ? this.wrapArray(base, arrayDepth) : base;
+	}
+	/** Wrap `base` in `Array<...>` `depth` times, instead of appending `[]` suffixes. */
+	wrapArray(base, depth) {
+		let result = base;
+		for (let i = 0; i < depth; i++) result = `Array<${result}>`;
+		return result;
+	}
+};
+//#endregion
+//#region src/SchemaPrinter/YupSchemaPrinter.ts
+var YupSchemaPrinter = class extends SchemaPrinterAbstract {
+	print(schema, io) {
+		return this.main(schema.describe(), io);
+	}
+	main(d, io, asKey = false) {
+		let base = "";
+		if (d.oneOf?.length) base = d.oneOf.filter((v) => v === null || [
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof v)).sort().map((v) => this.literal(v)).join(" | ");
+		if (base === "") switch (d.type) {
+			case "string":
+			case "number":
+			case "boolean":
+				base = d.type;
+				break;
+			case "date":
+				base = "Date";
+				break;
+			case "array":
+				base = d.innerType ? `Array<${this.main(d.innerType, io)}>` : "Array<unknown>";
+				break;
+			case "tuple":
+				base = d.innerType ? `[${d.innerType.map((i) => this.main(i, io)).join(", ")}]` : "Array<unknown>";
+				break;
+			case "object": {
+				const entries = Object.entries(d.fields).sort(([a], [b]) => a.localeCompare(b)).map(([k, f]) => `${this.key(k)}${f.optional ? "?" : ""}: ${this.main(f, io, true)}`);
+				base = entries.length === 0 ? "{}" : `{ ${entries.join("; ")} }`;
+				break;
+			}
+			default: base = "unknown";
+		}
+		if (d.optional && !asKey) base += ` | undefined`;
+		if (d.nullable) base += ` | null`;
+		return base;
+	}
+};
+//#endregion
+//#region src/SchemaPrinter/ZodSchemaPrinter.ts
+/** Field types that make an object key optional on the given side. */
+const OPTIONAL_IN = /* @__PURE__ */ new Set([
+	"optional",
+	"default",
+	"prefault"
+]);
+var ZodSchemaPrinter = class extends SchemaPrinterAbstract {
+	print(schema, io) {
+		return this.main(schema._zod.def, io);
+	}
+	main(def, io, asKey = false) {
+		const inner = (d = def) => this.main(d.innerType._zod.def, io);
+		switch (def.type) {
+			case "string":
+			case "number":
+			case "boolean":
+			case "bigint":
+			case "symbol":
+			case "null":
+			case "undefined":
+			case "void":
+			case "any":
+			case "unknown":
+			case "never": return def.type;
+			case "int":
+			case "nan": return "number";
+			case "date": return "Date";
+			case "file": return "File";
+			case "literal": return def.values.sort().map((v) => this.literal(v)).join(" | ");
+			case "enum": return [...new Set(Object.values(def.entries))].sort().map((v) => this.literal(v)).join(" | ");
+			case "optional": return asKey ? inner() : `${inner()} | undefined`;
+			case "nullable": return `${inner()} | null`;
+			case "nonoptional":
+			case "readonly":
+			case "catch": return inner();
+			case "default":
+			case "prefault": return io === "in" && !asKey ? `${inner()} | undefined` : inner();
+			case "success": return io === "in" ? inner() : "boolean";
+			case "promise": return `Promise<${inner()}>`;
+			case "lazy": return this.main(def.getter()._zod.def, io);
+			case "array": return `Array<${this.main(def.element._zod.def, io)}>`;
+			case "set": return `Set<${this.main(def.valueType._zod.def, io)}>`;
+			case "map": return `Map<${this.main(def.keyType._zod.def, io)}, ${this.main(def.valueType._zod.def, io)}>`;
+			case "record": return `Record<${this.main(def.keyType._zod.def, io)}, ${this.main(def.valueType._zod.def, io)}>`;
+			case "tuple": {
+				const items = def.items.map((i) => this.main(i._zod.def, io));
+				if (def.rest) items.push(`...Array<${this.main(def.rest._zod.def, io)}>`);
+				return `[${items.join(", ")}]`;
+			}
+			case "union": return def.options.map((o) => this.main(o._zod.def, io)).join(" | ");
+			case "intersection": {
+				const left = this.main(def.left._zod.def, io);
+				const right = this.main(def.right._zod.def, io);
+				return this.mergeObjects(left, right) ?? `${this.wrap(left)} & ${this.wrap(right)}`;
+			}
+			case "pipe": return this.main((io === "in" ? def.in : def.out)._zod.def, io);
+			case "object": {
+				const entries = Object.entries(def.shape).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => {
+					const vd = v._zod.def;
+					const optional = vd.type === "optional" || io === "in" && OPTIONAL_IN.has(vd.type);
+					return `${this.key(k)}${optional ? "?" : ""}: ${this.main(vd, io, optional)}`;
+				});
+				if (def.catchall) {
+					const ct = this.main(def.catchall._zod.def, io);
+					entries.push(`[k: string]: ${ct}`);
+				}
+				return entries.length === 0 ? "{}" : `{ ${entries.join("; ")} }`;
+			}
+			case "template_literal": return `\`${def.parts.sort().map((p) => p !== null && typeof p === "object" && "_zod" in p ? `\${${this.main(p._zod.def, io)}}` : String(p)).join("")}\``;
+			case "function": return `(...args: ${def.input ? this.main(def.input._zod.def, io) : "[...args: unknown[]]"}) => ${def.output ? this.main(def.output._zod.def, io) : "unknown"}`;
+			default: return "unknown";
+		}
+	}
+	/** Flatten `{ a } & { b }` into a single sorted object literal; null if either side isn't a plain object. */
+	mergeObjects(a, b) {
+		const members = (s) => {
+			const m = /^\{\s*([\s\S]*?)\s*\}$/.exec(s.trim());
+			if (!m) return null;
+			return m[1].length === 0 ? [] : this.split(m[1], ";");
+		};
+		const ma = members(a);
+		const mb = members(b);
+		if (!ma || !mb) return null;
+		const byKey = /* @__PURE__ */ new Map();
+		for (const entry of [...ma, ...mb]) {
+			const colon = this.topLevelColon(entry);
+			const key = colon === -1 ? entry : entry.slice(0, colon).replace(/\?$/, "").trim();
+			byKey.set(key, entry);
+		}
+		const sorted = [...byKey.entries()].sort(([x], [y]) => x.localeCompare(y)).map(([, v]) => v);
+		return sorted.length === 0 ? "{}" : `{ ${sorted.join("; ")} }`;
+	}
+};
+//#endregion
+//#region src/SchemaPrinter/index.ts
+var SchemaPrinter = class {
+	ark = new ArkSchemaPrinter();
+	zod = new ZodSchemaPrinter();
+	yup = new YupSchemaPrinter();
+	print(schema, io) {
+		if (!("~standard" in schema)) return /* @__PURE__ */ new Error(`Schema doesn't have "~standard" property.`);
+		if (!("vendor" in schema["~standard"])) return /* @__PURE__ */ new Error(`Schema doesn't have ["~standard"].vendor property.`);
+		try {
+			switch (schema["~standard"].vendor) {
+				case "zod": return this.zod.print(schema, io);
+				case "yup": return this.yup.print(schema, io);
+				default: return this.ark.print(schema, io);
+			}
+		} catch (err) {
+			return err;
+		}
+	}
+};
+//#endregion
+//#region src/exports/generateApiClient.ts
+const MODEL_KEYS = [
+	"body",
+	"search",
+	"params",
+	"response"
+];
+const CT_GENERIC = `CT extends "json" | "formData" = "json"`;
+const schemaPrinter = new SchemaPrinter();
+const typeToNameMap = /* @__PURE__ */ new Map();
+const toCamelCaseKey = cache("toCamelCaseKey", (endpoint, method, globalPrefix, ignoreGlobalPrefix) => {
+	let path = endpoint;
+	if (ignoreGlobalPrefix && globalPrefix) {
+		const prefixWithSlash = globalPrefix.startsWith("/") ? globalPrefix : `/${globalPrefix}`;
+		if (path.startsWith(prefixWithSlash)) path = path.slice(prefixWithSlash.length);
+	}
+	let result = path.split("/").filter((part) => part.length > 0).map((part, index) => {
+		let cleanPart = part.startsWith(":") ? part.substring(1) : part;
+		cleanPart = cleanPart.replace(/-([a-zA-Z0-9])/g, (_, char) => {
+			return char.toUpperCase();
+		});
+		cleanPart = cleanPart.replace(/[^a-zA-Z0-9_]/g, "_");
+		if (index === 0) return cleanPart;
+		return cleanPart.charAt(0).toUpperCase() + cleanPart.slice(1);
+	}).join("");
+	if (/^\d/.test(result)) result = "_" + result;
+	return result + method.slice(0, 1).toUpperCase() + method.slice(1).toLowerCase();
+});
+const toPascalCaseKey = cache("toPascalCaseKey", (endpoint, method, globalPrefix, ignoreGlobalPrefix) => {
+	const camel = toCamelCaseKey(endpoint, method, globalPrefix, ignoreGlobalPrefix);
+	return camel.charAt(0).toUpperCase() + camel.slice(1);
+});
+const extractParams = cache("extractParams", (endpoint) => {
+	const named = endpoint.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g)?.map((p) => p.substring(1)) ?? [];
+	if (endpoint.includes("*")) named.push("*");
+	return named;
+});
+const getTypeName = cache("getTypeName", (pascal, ns) => {
+	if (!ns) return pascal;
+	return `${pascal}${toPascalCase(ns)}`;
+});
+const getTypeBody = cache("getTypeBody", (endpoint, params, modelKey, schema) => {
+	if (isAbsent(schema)) {
+		if (modelKey === "params") {
+			if (!isSomeArray(params)) return null;
+			return `{ ${params.map((p) => `${p === "*" ? "\"*\"" : p}: primitive`).join("; ")} }`;
+		}
+		if (modelKey === "search") return `UnknownRecord | undefined`;
+		if (modelKey === "response") return `void`;
+		return null;
+	}
+	const res = schemaPrinter.print(schema, modelKey === "response" ? "out" : "in");
+	if (res instanceof Error) {
+		logger.error(`ERROR ${endpoint} ${modelKey}`, res);
+		return null;
+	}
+	if (modelKey === "body") return `CT extends "formData" ? FormData : ${res}`;
+	return res;
+});
+const getTypeLine = cache("getTypeLine", (modelKey, name, type, inner = false) => {
+	const existing = typeToNameMap.get(type);
+	const ib = new StringBuilder();
+	if (!existing) typeToNameMap.set(type, name);
+	if (!inner) ib.line(`export type ${name}`);
+	if (modelKey === "body" && !inner) ib.inline(`<${CT_GENERIC}>`);
+	const optional = type.endsWith(`| undefined`) ? `?` : ``;
+	ib.inline(inner ? `${modelKey}${optional}: ` : ` = `);
+	ib.inline(existing ?? type);
+	if (existing && modelKey === "body") ib.inline(`<CT>`);
+	return ib.toString();
+});
+function generateApiClient(prefix, routesArr, config) {
+	const b = new StringBuilder();
+	const routes = routesArr.map((route) => {
+		const camelKey = toCamelCaseKey(route.endpoint, route.method, prefix, config.ignoreGlobalPrefix);
+		const pascalKey = toPascalCaseKey(route.endpoint, route.method, prefix, config.ignoreGlobalPrefix);
+		const params = extractParams(route.endpoint);
+		return {
+			...route,
+			id: route.id,
+			camelKey,
+			pascalKey,
+			params
+		};
+	});
+	writeBase(b, routes);
+	for (const route of routes) writeRouteTypes(b, route);
+	for (const route of routes) writeRouteModel(b, route);
+	b.line(``);
+	b.line(`export const endpoints = {`);
+	for (const route of routes) writeEndpoint(b, route);
+	b.line(`};`);
+	if (!config.apiClient.disabled) {
+		b.line(``);
+		b.line(`export class ${config.apiClient.exportAs} {`);
+		writeApiClientBoilerplate(b, config.apiClient.useStaticClass);
+		for (const route of routes) writeApiClientMethod(b, route, config.apiClient.useStaticClass);
+		b.line(`}`);
+	}
+	const content = b.toString();
+	const segments = config.output.split("/");
+	const dirName = segments.slice(0, -1);
+	const fileName = segments[segments.length - 1] ?? "corpus.gen.ts";
+	const fpath = path.join(process.cwd(), ...dirName, fileName);
+	fs.mkdirSync(path.dirname(fpath), { recursive: true });
+	fs.writeFileSync(fpath, content);
+	logger.info(`Api Client written to: ${fpath}`);
+}
+function writeBase(b, routes) {
+	const wildcardExists = routes.some((r) => r.endpoint.includes("*"));
+	b.line(`// #region base`);
+	b.line(`type UnknownRecord = Record<string, unknown>;`);
+	typeToNameMap.set(`Record<string, unknown>`, `UnknownRecord`);
+	b.line(`type primitive = string | number | boolean;`);
+	typeToNameMap.set(`string | number | boolean`, `primitive`);
+	if (wildcardExists) {
+		b.line(`type wildcard = { "*": primitive };`);
+		typeToNameMap.set(`{ "*": primitive }`, `wildcard`);
+	}
+	b.line(`type args<T> = Omit<T, "response"> & { init?: RequestInit; };`);
+	b.line(``);
+	b.line(`export interface RequestDescriptor {`);
+	b.line(1)(`endpoint: string;`);
+	b.line(1)(`method: string;`);
+	b.line(1)(`body?: unknown;`);
+	b.line(1)(`search?: UnknownRecord;`);
+	b.line(1)(`init?: RequestInit;`);
+	b.line(`}`);
+	b.line(`// #endregion`);
+	b.line(``);
+}
+function writeRouteTypes(b, route) {
+	b.line(``);
+	b.line(`// #region ${route.id} types`);
+	for (const modelKey of MODEL_KEYS) {
+		const schema = route.config?.[modelKey];
+		const name = getTypeName(route.pascalKey, modelKey);
+		const type = getTypeBody(route.endpoint, route.params, modelKey, schema);
+		if (!type) continue;
+		b.line(getTypeLine(modelKey, name, type));
+	}
+	b.line(`// #endregion`);
+}
+function writeRouteModel(b, route) {
+	b.line(``);
+	b.line(`// #region ${route.id} model`);
+	b.line(`export interface ${getTypeName(route.pascalKey, "Model")}`);
+	if (!isAbsent(route.config?.body)) b.inline(`<${CT_GENERIC}>`);
+	b.inline(` {`);
+	for (const modelKey of MODEL_KEYS) {
+		const schema = route.config?.[modelKey];
+		const name = getTypeName(route.pascalKey, modelKey);
+		const type = getTypeBody(route.endpoint, route.params, modelKey, schema);
+		if (!type) continue;
+		b.line(1)(getTypeLine(modelKey, name, type, true));
+	}
+	b.line(`}`);
+	b.line(`// #endregion`);
+}
+function writeEndpoint(b, route) {
+	const modelInterfaceKey = getTypeName(route.pascalKey, "Model");
+	const endpoint = isSomeArray(route.params) ? `(p: ${modelInterfaceKey}["params"]) => \`${route.endpoint.split(/:([a-zA-Z_][a-zA-Z0-9_]*)/).map((part, i) => i % 2 === 1 ? `\${String(p.${part})}` : part.replace("*", `\${String(p["*"])}`)).join("")}\`` : `"${route.endpoint}"`;
+	b.line(1)(`${route.camelKey}: ${endpoint},`);
+}
+function writeApiClientBoilerplate(b, useStaticClass) {
+	const pfx = useStaticClass ? "static" : "public";
+	b.line(1)(`constructor(public readonly baseUrl: string) {}`);
+	b.line(``);
+	b.line(1)(`${pfx} fetchFn: <R>(args: RequestDescriptor) => Promise<R> = async (args) => {`);
+	b.line(2)(`const url = new URL(args.endpoint, this.baseUrl);`);
+	b.line(2)(`const headers = new Headers(args.init?.headers);`);
+	b.line(2)(`const method: RequestInit["method"] = args.method;`);
+	b.line(2)(`let body: RequestInit["body"];`);
+	b.line(2)(`if (args.search) {`);
+	b.line(3)(`for (const [key, val] of Object.entries(args.search)) {`);
+	b.line(4)(`if (val == null) continue;`);
+	b.line(4)(`url.searchParams.append(key, typeof val === "object"`);
+	b.line(5)(`? JSON.stringify(val)`);
+	b.line(5)(`: String(val as primitive));`);
+	b.line(3)(`}`);
+	b.line(2)(`}`);
+	b.line(2)(`if (args.body) {`);
+	b.line(3)(`if (!headers.has("content-type") && !(args.body instanceof FormData)) {`);
+	b.line(4)(`headers.set("content-type", "application/json");`);
+	b.line(3)(`}`);
+	b.line(3)(`body = args.body instanceof FormData ? args.body : JSON.stringify(args.body);`);
+	b.line(2)(`}`);
+	b.line(2)(`const req = new Request(url, { method, headers, body, ...args.init });`);
+	b.line(2)(`const res = await fetch(req);`);
+	b.line(2)(`const contentType = res.headers.get("content-type");`);
+	b.line(2)(`const isJson = contentType?.includes("application/json");`);
+	b.line(2)(`const isText = contentType?.includes("text/");`);
+	b.line(2)(`let data: any;`);
+	b.line(2)(`let err: string;`);
+	b.line(2)(`if (isJson) {`);
+	b.line(3)(`data = await res.json();`);
+	b.line(3)(`err = data.message ?? res.statusText;`);
+	b.line(3)(`body = args.body instanceof FormData ? args.body : JSON.stringify(args.body);`);
+	b.line(2)(`} else if (isText) {`);
+	b.line(3)(`data = await res.text();`);
+	b.line(3)(`err = data !== "" ? data : res.statusText;`);
+	b.line(2)(`} else {`);
+	b.line(3)(`data = await res.blob();`);
+	b.line(3)(`err = res.statusText;`);
+	b.line(2)(`}`);
+	b.line(2)(`if (!res.ok) throw new Error(err, { cause: data })`);
+	b.line(2)(`return data;`);
+	b.line(1)(`}`);
+	b.line(``);
+	b.line(1)(`${pfx} setFetchFn(cb: <R>(args: RequestDescriptor) => Promise<R>): void {`);
+	b.line(2)(`this.fetchFn = cb;`);
+	b.line(1)(`}`);
+	b.line(``);
+	b.line(1)(`${pfx} readonly endpoints = endpoints;`);
+	b.line(``);
+}
+function writeApiClientMethod(b, route, useStaticClass) {
+	const pfx = useStaticClass ? "static" : "public";
+	const endpoint = `this.endpoints.${route.camelKey}${isSomeArray(route.params) ? `(args.params)` : ``}`;
+	const generic = !isAbsent(route.config?.body) ? `<${CT_GENERIC}>` : ``;
+	const args = `args: args<${getTypeName(route.pascalKey, "Model")}${!isAbsent(route.config?.body) ? `<CT>` : ``}>`;
+	b.line(``);
+	b.line(1)(`/** ${route.id} */`);
+	b.line(1)(`${pfx} ${route.camelKey}${generic}(${args}) {`);
+	b.line(2)(`return this.fetchFn<${getTypeName(route.pascalKey, "response")}>({`);
+	b.line(3)(`endpoint: ${endpoint},`);
+	b.line(3)(`method: ${quote(route.method)},`);
+	b.line(3)(`...args,`);
+	b.line(2)(`});`);
+	b.line(1)(`}`);
+}
+//#endregion
+export { defineConfig, generateApiClient };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "https://www.schemastore.org/package.json",
+  "name": "@ozanarslan/corpus-cli",
+  "version": "0.0.1",
+  "description": "CLI for @ozanarslan/corpus",
+  "license": "MIT",
+  "author": "Ozan Arslan <ozanarslanwork@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ozanArslan2424/corpus.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "corpus": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "LICENSE.txt"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./cli": "./dist/cli.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "oxc-parser": "^0.147.0"
+  },
+  "devDependencies": {
+    "@ozanarslan/corpus": "0.0.1",
+    "@types/bun": "^1.4.0",
+    "arktype": "^2.2.3",
+    "tsdown": "^0.22.14",
+    "yup": "^1.7.1",
+    "zod": "^4.4.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "NODE_ENV=development bun run ./src/cli.ts",
+    "api": "bun run ./dist/cli.mjs api -m ./test/other/apigen/startServer.ts -o ./test/other/apigen/generated.ts",
+    "test:api": "bun api -s && bun run ./test/other/integration.ts -s",
+    "test:all": "VALI=arktype bun test:api && VALI=zod bun test:api && VALI=yup bun test:api"
+  }
+}