@kizunajs/fetch 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/server.mjs

@@ -1,435 +0,0 @@
-import { ValidationErrorSchema } from "kizunajs/schemas";
-import { isBinarySchema, isFileSchema, isStreamResponse, readDef, readDeprecation, readDiscriminatedUnion, readMetaDescription, readMetaExamples, readMetaId, readObjectShape, resolveResponseBody, resolveResponseHeaders, streamContentType, toPascalCase, unwrapOptionalWrappers } from "kizunajs/generator";
-//#region src/zod-to-typescript.ts
-/**
-* Collects the named types a walk produces, so a model shared by many routes is
-* declared once.
-*/
-var TypeCollector = class {
-	named = /* @__PURE__ */ new Map();
-	claimed = /* @__PURE__ */ new Set();
-	/**
-	* Claims a name before its body is walked, so a model that refers to itself
-	* resolves to its own name instead of recursing. Answers whether the caller
-	* is the one that has to emit it.
-	*/
-	claim(name) {
-		if (this.claimed.has(name)) return false;
-		this.claimed.add(name);
-		return true;
-	}
-	add(type) {
-		this.named.set(type.name, type);
-	}
-	all() {
-		return [...this.named.values()].sort((left, right) => left.name.localeCompare(right.name));
-	}
-};
-const quote = (value) => JSON.stringify(value);
-const indent$1 = (text, depth = 1) => text.split("\n").map((line) => line.length > 0 ? "    ".repeat(depth) + line : line).join("\n");
-/**
-* A property name, quoted only when it is not a plain identifier.
-*/
-const propertyKey = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : quote(key);
-/**
-* A doc comment over the lines it is given, or nothing when there are none.
-* Always multi-line, the way the rest of this repository writes them.
-*/
-const docComment = (lines) => {
-	const body = lines.flatMap((line) => line.split("\n"));
-	if (body.length === 0) return "";
-	return `/**\n${body.map((line) => ` * ${line}`.trimEnd()).join("\n")}\n */\n`;
-};
-/**
-* Renders a declared example as the TypeScript literal a caller would write.
-*/
-const exampleLiteral = (value) => {
-	if (typeof value === "string") return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-	if (value === void 0) return "undefined";
-	return JSON.stringify(value) ?? "undefined";
-};
-const STRING_SAMPLES = {
-	email: "ada@example.com",
-	url: "https://example.com",
-	uuid: "3f1c2d9e-5b6a-4c7d-8e9f-0a1b2c3d4e5f",
-	datetime: "2026-01-01T00:00:00Z",
-	date: "2026-01-01",
-	time: "00:00:00"
-};
-const stringSample = (schema, key) => {
-	const def = readDef(schema);
-	const formats = [def.format, ...(def.checks ?? []).map((check) => check.format ?? check.def?.format)];
-	for (const format of formats) if (format !== void 0 && format in STRING_SAMPLES) return exampleLiteral(STRING_SAMPLES[format]);
-	if (key !== void 0 && /id$/i.test(key)) return exampleLiteral("1");
-	return exampleLiteral("string");
-};
-/**
-* A value a caller could pass for a schema, used in the `@example` on each
-* client method. A schema that declares an example is taken at its word;
-* anything else gets a value of the right shape.
-*/
-const sampleValue = (schema, depth = 0, key) => {
-	const [declared] = readMetaExamples(schema);
-	if (declared !== void 0) return exampleLiteral(declared);
-	if (isFileSchema(schema)) return "new File([], 'upload.txt')";
-	if (isBinarySchema(schema)) return "new Uint8Array()";
-	const def = readDef(schema);
-	if (def.type === "default" && def.defaultValue !== void 0) return exampleLiteral(def.defaultValue);
-	if (def.type === "pipe") {
-		const side = def.out ?? def.in;
-		return side ? sampleValue(side, depth, key) : "undefined";
-	}
-	if (def.innerType && def.type !== "object") return sampleValue(def.innerType, depth, key);
-	switch (def.type) {
-		case "number":
-		case "int": return "1";
-		case "bigint": return "1n";
-		case "boolean": return "true";
-		case "date": return exampleLiteral("2026-01-01");
-		case "null": return "null";
-		case "literal": return def.values?.length ? exampleLiteral(def.values[0]) : "undefined";
-		case "enum": {
-			const [first] = Object.values(def.entries ?? {});
-			return first === void 0 ? "undefined" : exampleLiteral(first);
-		}
-		case "array":
-			if (!def.element || depth >= SAMPLE_DEPTH) return "[]";
-			return `[\n${indent$1(`${sampleValue(def.element, depth + 1, key)},`)}\n]`;
-		case "object": return sampleObject(schema, depth);
-		case "record": return "{}";
-		case "union": {
-			const options = readDiscriminatedUnion(schema)?.options ?? def.options ?? [];
-			return options[0] ? sampleValue(options[0], depth, key) : "undefined";
-		}
-		case "string": return stringSample(schema, key);
-		default: return "undefined";
-	}
-};
-const SAMPLE_DEPTH = 2;
-/**
-* The required fields of an object schema, written as the literal a caller
-* would pass. Optional fields are left out, since an example shows the least
-* the route needs.
-*/
-const sampleObject = (schema, depth = 0) => {
-	const shape = readObjectShape(schema);
-	if (!shape) return "{}";
-	const required = Object.entries(shape).filter(([, field]) => !unwrapOptionalWrappers(field).optional);
-	if (required.length === 0 || depth >= SAMPLE_DEPTH) return "{}";
-	return `{\n${indent$1(required.map(([key, field]) => `${propertyKey(key)}: ${sampleValue(unwrapOptionalWrappers(field).inner, depth + 1, key)},`).join("\n"))}\n}`;
-};
-/**
-* What an editor shows above a field: its description, whether it is on its way
-* out, and the values the schema declares as examples.
-*/
-const fieldDoc = (field) => {
-	const lines = [];
-	const description = readMetaDescription(field);
-	if (description !== void 0) lines.push(description);
-	const deprecation = readDeprecation(field);
-	if (deprecation !== void 0) {
-		if (lines.length > 0) lines.push("");
-		lines.push(`@deprecated ${deprecation.message ?? ""}`.trimEnd());
-	}
-	for (const example of readMetaExamples(field)) {
-		if (lines.length > 0) lines.push("");
-		lines.push("@example", exampleLiteral(example));
-	}
-	return lines;
-};
-const objectBody = (schema, collector, hint) => {
-	const shape = readObjectShape(schema);
-	if (!shape) return "Record<string, unknown>";
-	const entries = Object.entries(shape);
-	if (entries.length === 0) return "Record<string, never>";
-	return `{\n${indent$1(entries.map(([key, field]) => {
-		const doc = docComment(fieldDoc(field));
-		const mark = unwrapOptionalWrappers(field).optional ? "?" : "";
-		return `${doc}${propertyKey(key)}${mark}: ${typeOf(field, collector, `${hint}${toPascalCase(key)}`)};`;
-	}).join("\n"))}\n}`;
-};
-/**
-* The TypeScript type a schema describes. Named models are collected and
-* referenced; anonymous shapes are inlined.
-*/
-const typeOf = (schema, collector, hint) => {
-	if (isFileSchema(schema)) return "File | Blob";
-	if (isBinarySchema(schema)) return "Uint8Array";
-	const def = readDef(schema);
-	if (def.type === "nullable" && def.innerType) return `${typeOf(def.innerType, collector, hint)} | null`;
-	if (def.type === "nullish" && def.innerType) return `${typeOf(def.innerType, collector, hint)} | null`;
-	if (def.innerType && def.type !== "object") {
-		const { inner } = unwrapOptionalWrappers(schema);
-		if (inner !== schema) return typeOf(inner, collector, hint);
-		return typeOf(def.innerType, collector, hint);
-	}
-	if (def.type === "pipe") {
-		const side = def.out ?? def.in;
-		return side ? typeOf(side, collector, hint) : "unknown";
-	}
-	const modelName = readMetaId(schema);
-	if (modelName !== void 0 && def.type === "object") {
-		if (collector.claim(modelName)) collector.add({
-			name: modelName,
-			description: readMetaDescription(schema),
-			body: objectBody(schema, collector, modelName)
-		});
-		return modelName;
-	}
-	switch (def.type) {
-		case "string": return "string";
-		case "number":
-		case "int": return "number";
-		case "bigint": return "string";
-		case "boolean": return "boolean";
-		case "date": return "string";
-		case "null": return "null";
-		case "any":
-		case "unknown": return "unknown";
-		case "never": return "never";
-		case "void":
-		case "undefined": return "undefined";
-		case "literal": {
-			const values = def.values ?? [];
-			return values.length > 0 ? values.map((value) => quote(String(value))).join(" | ") : "never";
-		}
-		case "enum": {
-			const values = Object.values(def.entries ?? {});
-			return values.length > 0 ? values.map((value) => quote(String(value))).join(" | ") : "never";
-		}
-		case "array": return def.element ? `Array<${typeOf(def.element, collector, `${hint}Item`)}>` : "unknown[]";
-		case "object": return objectBody(schema, collector, hint);
-		case "record": return `Record<string, ${def.valueType ? typeOf(def.valueType, collector, `${hint}Value`) : "unknown"}>`;
-		case "union": {
-			const options = readDiscriminatedUnion(schema)?.options ?? def.options ?? [];
-			if (options.length === 0) return "unknown";
-			return options.map((option, index) => typeOf(option, collector, `${hint}${index}`)).join(" | ");
-		}
-		default: return "unknown";
-	}
-};
-//#endregion
-//#region src/generator.ts
-const indent = (text, depth = 1) => text.split("\n").map((line) => line.length > 0 ? "    ".repeat(depth) + line : line).join("\n");
-const pathParamNames = (path) => [...path.matchAll(/:([A-Za-z0-9_]+)/g)].map((match) => match[1] ?? "");
-/**
-* One server-sent event, typed from what the response declares. A record of
-* event name to schema becomes a union discriminated on `event`; a single
-* schema is the only shape a message takes.
-*/
-const eventUnion = (stream, collector, namespace) => {
-	const frame = "id?: string; retry?: number";
-	if (stream && typeof stream === "object" && !("_zod" in stream) && !("_def" in stream)) {
-		const arms = Object.entries(stream).map(([event, schema]) => `{ event: '${event}'; data: ${typeOf(schema, collector, `${namespace}${toPascalCase(event)}`)}; ${frame} }`);
-		return arms.length > 0 ? arms.join(" | ") : `{ event?: string; data: string; ${frame} }`;
-	}
-	return `{ event?: string; data: ${typeOf(stream, collector, `${namespace}Message`)}; ${frame} }`;
-};
-const streamBody = (mode, stream, collector, namespace) => {
-	if (mode === "binary") return "AsyncIterable<Uint8Array>";
-	if (mode === "text") return "AsyncIterable<string>";
-	return `AsyncIterable<${eventUnion(stream, collector, namespace)}>`;
-};
-/**
-* The call a route's `@example` shows: the arguments it cannot be called
-* without, filled with values of the shape each schema declares.
-*/
-const exampleCall = (routeKey, route) => {
-	const entries = [];
-	const params = pathParamNames(route.path);
-	if (params.length > 0) {
-		const shape = route.pathParams ? readObjectShape(route.pathParams) : void 0;
-		const fields = params.map((name) => {
-			const declared = shape?.[name];
-			return `${name}: ${declared ? sampleValue(declared, 0, name) : "'1'"},`;
-		});
-		entries.push(`params: {\n${indent(fields.join("\n"))}\n},`);
-	}
-	if (route.query && requiresArgument(route.query)) entries.push(`query: ${sampleObject(route.query)},`);
-	if (route.body && requiresArgument(route.body)) entries.push(`body: ${sampleValue(route.body)},`);
-	return `const result = await client.${routeKey}(${entries.length > 0 ? `{\n${indent(entries.join("\n"))}\n}` : ""});`;
-};
-/**
-* Whether a schema has anything a caller has to pass, so a route whose query is
-* every-field-optional keeps its example to the call itself.
-*/
-const requiresArgument = (schema) => {
-	const shape = readObjectShape(schema);
-	if (!shape) return true;
-	return Object.values(shape).some((field) => !unwrapOptionalWrappers(field).optional);
-};
-/**
-* What an editor shows above a client method: what the route is for, whether it
-* is on its way out, and how it is called.
-*/
-const routeDoc = (routeKey, route) => {
-	const lines = [];
-	if (route.summary) lines.push(route.summary);
-	if (route.description) {
-		if (lines.length > 0) lines.push("");
-		lines.push(route.description);
-	}
-	if (route.deprecated !== void 0 && route.deprecated !== false) {
-		const message = typeof route.deprecated === "string" ? route.deprecated : typeof route.deprecated === "object" ? route.deprecated.message : void 0;
-		if (lines.length > 0) lines.push("");
-		lines.push(`@deprecated ${message ?? ""}`.trimEnd());
-	}
-	if (lines.length > 0) lines.push("");
-	lines.push("@example", exampleCall(routeKey, route));
-	return docComment(lines);
-};
-const emitRoute = (routeKey, key, route, collector) => {
-	const namespace = routeKey.split(".").map(toPascalCase).join("");
-	const members = [];
-	const args = [];
-	const params = pathParamNames(route.path);
-	if (params.length > 0) {
-		const body = route.pathParams ? typeOf(route.pathParams, collector, `${namespace}Params`) : `{\n${indent(params.map((name) => `${name}: string;`).join("\n"))}\n}`;
-		members.push(`export type Params = ${body};`);
-		args.push(`params: API.${namespace}.Params`);
-	}
-	if (route.query) {
-		members.push(`export type Query = ${typeOf(route.query, collector, `${namespace}Query`)};`);
-		args.push(`query?: API.${namespace}.Query`);
-	}
-	if (route.body) {
-		members.push(`export type Body = ${typeOf(route.body, collector, `${namespace}Body`)};`);
-		args.push(`body: API.${namespace}.Body`);
-	}
-	if (route.headers) {
-		members.push(`export type Headers = ${typeOf(route.headers, collector, `${namespace}Headers`)};`);
-		args.push(`headers?: API.${namespace}.Headers`);
-	} else args.push("headers?: Record<string, string>");
-	args.push("fetchOptions?: RequestInit");
-	const validates = route.body !== void 0 || route.query !== void 0;
-	const declaredBadRequest = Object.keys(route.responses).includes("400");
-	const validationBody = validates ? typeOf(ValidationErrorSchema, collector, "ValidationError") : void 0;
-	const results = Object.entries(route.responses).map(([status, response]) => {
-		const headers = resolveResponseHeaders(response);
-		const headerType = headers ? typeOf(headers, collector, `${namespace}${status}Headers`) : "Record<string, string>";
-		if (isStreamResponse(response)) return `{ status: ${status}; body: ${streamBody(streamContentType(response).includes("event-stream") ? "events" : streamContentType(response).startsWith("text/") ? "text" : "binary", response.stream, collector, `${namespace}${status}`)}; headers: ${headerType} }`;
-		const schema = resolveResponseBody(response);
-		const body = schema ? typeOf(schema, collector, `${namespace}${status}`) : "undefined";
-		return `{ status: ${status}; body: ${status === "400" && validationBody ? `${body} | ${validationBody}` : body}; headers: ${headerType} }`;
-	});
-	if (validationBody && !declaredBadRequest) results.push(`{ status: 400; body: ${validationBody}; headers: Record<string, string> }`);
-	members.push(`export type Result =\n${indent(results.map((result) => `| ${result}`).join("\n"))};`);
-	const argsType = `{\n${indent(args.map((arg) => `${arg};`).join("\n"))}\n}`;
-	const tableEntries = [`method: '${route.method}'`, `path: '${route.path}'`];
-	if (route.contentType) tableEntries.push(`contentType: '${route.contentType}'`);
-	const responses = Object.entries(route.responses).map(([status, response]) => isStreamResponse(response) ? `${status}: { stream: { contentType: '${streamContentType(response)}' } }` : `${status}: {}`);
-	tableEntries.push(`responses: {\n${indent(responses.map((entry) => `${entry},`).join("\n"))}\n}`);
-	const streams = Object.values(route.responses).some((response) => isStreamResponse(response));
-	return {
-		namespace,
-		signature: `${routeDoc(routeKey, route)}${key}: ClientMethod<'${route.method}', ${streams}, ${argsType}, API.${namespace}.Result>;`,
-		declaration: `export namespace ${namespace} {\n${indent(members.join("\n\n"))}\n}`,
-		table: `${key}: {\n${indent(tableEntries.map((entry) => `${entry},`).join("\n"))}\n},`
-	};
-};
-const isRoute = (value) => !!value && typeof value === "object" && typeof value.method === "string";
-const emitTree = (routes, prefix, collector) => {
-	const signatures = [];
-	const tables = [];
-	const declarations = [];
-	for (const key of Object.keys(routes)) {
-		const node = routes[key];
-		const routeKey = prefix ? `${prefix}.${key}` : key;
-		if (isRoute(node)) {
-			const emitted = emitRoute(routeKey, key, node, collector);
-			signatures.push(emitted.signature);
-			tables.push(emitted.table);
-			declarations.push(emitted.declaration);
-			continue;
-		}
-		if (node && typeof node === "object") {
-			const group = emitTree(node, routeKey, collector);
-			signatures.push(`${key}: {\n${indent(group.signatures)}\n};`);
-			tables.push(`${key}: {\n${indent(group.table)}\n},`);
-			declarations.push(...group.declarations);
-		}
-	}
-	return {
-		signatures: signatures.join("\n"),
-		table: tables.join("\n"),
-		declarations
-	};
-};
-/**
-* Renders a TypeScript client from an api: its named types, the route table
-* the runtime reads, and a `createClient` typed against both.
-*/
-/**
-* The headers a request context declares, as one interface the caller fills
-* once. Absent when the API declares no request context that reads headers.
-*/
-const emitRequestContext = (contract, collector) => {
-	const declarations = Object.values(contract.requestContext ?? {});
-	const fields = [];
-	for (const declaration of declarations) {
-		const headers = declaration.headers;
-		if (!headers) continue;
-		const inner = typeOf(headers, collector, "RequestContext").trim().replace(/^\{/, "").replace(/\}$/, "").split("\n").map((line) => line.trim()).filter((line) => line !== "").join("\n");
-		if (inner !== "") fields.push(inner);
-	}
-	return fields.length > 0 ? `export interface RequestContext {\n${indent(fields.join("\n"))}\n}` : void 0;
-};
-const generateFetchClient = (contract, options = {}) => {
-	const { runtimeModule = "@kizunajs/fetch", regenerateCommand = "kizuna generate", source } = options;
-	const collector = new TypeCollector();
-	const tree = emitTree(contract.routes, "", collector);
-	const api = [...collector.all().map((model) => {
-		return `${model.description ? `/**\n * ${model.description}\n */\n` : ""}export type ${model.name} = ${model.body};`;
-	}), ...tree.declarations].join("\n\n");
-	const requestContext = emitRequestContext(contract, collector);
-	return `/* eslint-disable */
-/**
-${[
-		" * Generated by @kizunajs/fetch. Do not edit.",
-		" *",
-		...source === void 0 ? [] : [` * Source: ${source}`],
-		` * Regenerate: ${regenerateCommand}`
-	].join("\n")}
- */
-import { createGeneratedClient, type ClientConfig, type ClientMethod, type GeneratedRoutes } from '${runtimeModule}';
-
-export namespace API {
-${indent(api)}
-}
-
-export interface Client {
-${indent(tree.signatures)}
-}
-
-const routes: GeneratedRoutes = {
-${indent(tree.table)}
-};
-
-${requestContext === void 0 ? `/**
- * A client for this API. Pass the base URL and anything else the runtime takes.
- */
-export const createClient = (config: ClientConfig): Client => createGeneratedClient(routes, config) as unknown as Client;` : `${requestContext}
-
-/**
- * A client for this API. Pass the base URL, the request context headers this
- * API declares, and anything else the runtime takes.
- */
-export const createClient = (config: ClientConfig & { requestContext?: RequestContext }): Client =>
-    createGeneratedClient(routes, config) as unknown as Client;`}
-`;
-};
-//#endregion
-//#region src/client-target.ts
-/**
-* A TypeScript client target for `kizuna.config.ts`.
-*
-* @example
-* fetchClient({ output: './packages/api-client/src/generated.ts' });
-*/
-const fetchClient = ({ output, ...options }) => ({
-	kind: "fetch",
-	output,
-	generate: (contract) => generateFetchClient(contract, options)
-});
-//#endregion
-export { fetchClient, generateFetchClient };