@sohcah/openapi-generator 0.0.2 → 0.1.0

package/dist/generators/index.js

@@ -1,29 +1,144 @@
 import { __toESM } from "../chunk-51aI8Tpl.js";
-import { DocumentContext, NotImplementedError, ensureImport, ensureNamespaceImport, getKey, helpers_exports, require_lib } from "../helpers-CKmqJXD5.js";
-import { Effect } from "effect";
+import { DocumentContext, NotImplementedError, ensureImport, ensureNamespaceImport, getKey, helpers_exports, notImplementedStatement, require_lib } from "../helpers-CUZHcCFJ.js";
+import { Context, Effect } from "effect";
+import escapeRegex from "regex-escape";
 
+//#region src/generators/requestFormats/json.ts
+var import_lib$8 = /* @__PURE__ */ __toESM(require_lib(), 1);
+const generateJsonRequestCodec = Effect.fn(function* (options, schema, decoded) {
+	return options.transformer({
+		encoded: options.schema.string,
+		decoded,
+		decode: notImplementedStatement,
+		encode: import_lib$8.callExpression(import_lib$8.memberExpression(import_lib$8.identifier("JSON"), import_lib$8.identifier("stringify")), [import_lib$8.identifier("from")])
+	});
+});
+
+//#endregion
+//#region src/generators/requestFormats/formData.ts
+var import_lib$7 = /* @__PURE__ */ __toESM(require_lib(), 1);
+const maybeStringify = Effect.fn(function* (expression, schema) {
+	const resolved = yield* resolveSchema(schema);
+	if (resolved.type === "object" || resolved.type === "array") return import_lib$7.callExpression(import_lib$7.memberExpression(import_lib$7.identifier("JSON"), import_lib$7.identifier("stringify")), [expression]);
+	if (resolved.type === "string") return expression;
+	return import_lib$7.callExpression(import_lib$7.identifier("String"), [expression]);
+});
+const generateFormDataRequestCodec = Effect.fn(function* (options, schema, decoded) {
+	const encode = import_lib$7.blockStatement([import_lib$7.variableDeclaration("const", [import_lib$7.variableDeclarator(import_lib$7.identifier("formData"), import_lib$7.newExpression(import_lib$7.identifier("FormData"), []))])]);
+	const properties = schema.properties ?? {};
+	for (const [propertyKey, rawProperty] of Object.entries(properties)) {
+		const property = yield* resolveSchema(rawProperty);
+		const propertyExpression = import_lib$7.memberExpression(import_lib$7.identifier("from"), import_lib$7.stringLiteral(propertyKey), true);
+		if (property.type === "array") {
+			encode.body.push(import_lib$7.forOfStatement(import_lib$7.variableDeclaration("const", [import_lib$7.variableDeclarator(import_lib$7.identifier("propertyValue"))]), propertyExpression, import_lib$7.blockStatement([import_lib$7.expressionStatement(import_lib$7.callExpression(import_lib$7.memberExpression(import_lib$7.identifier("formData"), import_lib$7.identifier("append")), [import_lib$7.stringLiteral(propertyKey), yield* maybeStringify(import_lib$7.identifier("propertyValue"), property.items)]))])));
+			continue;
+		}
+		encode.body.push(import_lib$7.expressionStatement(import_lib$7.callExpression(import_lib$7.memberExpression(import_lib$7.identifier("formData"), import_lib$7.identifier("append")), [import_lib$7.stringLiteral(propertyKey), yield* maybeStringify(propertyExpression, property)])));
+	}
+	encode.body.push(import_lib$7.returnStatement(import_lib$7.identifier("formData")));
+	return options.transformer({
+		encoded: import_lib$7.callExpression(options.schema.instanceOf, [import_lib$7.identifier("FormData")]),
+		decoded,
+		decode: notImplementedStatement,
+		encode
+	});
+});
+
+//#endregion
+//#region src/generators/generatePathExpression.ts
+var import_lib$6 = /* @__PURE__ */ __toESM(require_lib(), 1);
+function generatePathExpression(path, pathParameters, queryParameter) {
+	let modifiedPath = path;
+	if (queryParameter) modifiedPath += "?";
+	const split = modifiedPath.split(new RegExp(`\\{(${Object.keys(pathParameters).map((i) => escapeRegex(i)).join("|")})\\}`, "g"));
+	const quasis = [];
+	const expressions = [];
+	for (const [i, part] of split.entries()) if (i % 2 === 0) quasis.push(import_lib$6.templateElement({
+		raw: part,
+		cooked: part
+	}, false));
+	else {
+		const paramExpression = pathParameters[part];
+		if (!paramExpression) throw new Error(`Path parameter ${part} not found`);
+		expressions.push(paramExpression);
+	}
+	if (queryParameter) {
+		expressions.push(queryParameter);
+		quasis.push(import_lib$6.templateElement({
+			raw: "",
+			cooked: ""
+		}, false));
+	}
+	return import_lib$6.templateLiteral(quasis, expressions);
+}
+
+//#endregion
+//#region src/generators/responseFormats/json.ts
+var import_lib$5 = /* @__PURE__ */ __toESM(require_lib(), 1);
+const generateJsonResponseCodec = Effect.fn(function* (options, schema, decoded) {
+	return options.transformer({
+		encoded: import_lib$5.callExpression(options.schema.instanceOf, [import_lib$5.identifier("Response")]),
+		decoded,
+		decode: import_lib$5.blockStatement([import_lib$5.tryStatement(import_lib$5.blockStatement([import_lib$5.returnStatement(import_lib$5.tsAsExpression(import_lib$5.awaitExpression(import_lib$5.callExpression(import_lib$5.memberExpression(import_lib$5.identifier("from"), import_lib$5.identifier("json")), [])), import_lib$5.tsAnyKeyword()))]), import_lib$5.catchClause(Object.assign(import_lib$5.identifier("error"), { typeAnnotation: import_lib$5.tsTypeAnnotation(import_lib$5.tsUnknownKeyword()) }), options.transformerCatch(import_lib$5.identifier("error"))))]),
+		decodeAsync: true,
+		encode: notImplementedStatement
+	});
+});
+
+//#endregion
+//#region src/generators/responseFormats/blob.ts
+var import_lib$4 = /* @__PURE__ */ __toESM(require_lib(), 1);
+const generateBlobResponseCodec = Effect.fn(function* (options) {
+	return options.transformer({
+		encoded: import_lib$4.callExpression(options.schema.instanceOf, [import_lib$4.identifier("Response")]),
+		decoded: import_lib$4.callExpression(options.schema.instanceOf, [import_lib$4.identifier("Blob")]),
+		decode: import_lib$4.blockStatement([import_lib$4.tryStatement(import_lib$4.blockStatement([import_lib$4.returnStatement(import_lib$4.tsAsExpression(import_lib$4.awaitExpression(import_lib$4.callExpression(import_lib$4.memberExpression(import_lib$4.identifier("from"), import_lib$4.identifier("blob")), [])), import_lib$4.tsAnyKeyword()))]), import_lib$4.catchClause(Object.assign(import_lib$4.identifier("error"), { typeAnnotation: import_lib$4.tsTypeAnnotation(import_lib$4.tsUnknownKeyword()) }), options.transformerCatch(import_lib$4.identifier("error"))))]),
+		decodeAsync: true,
+		encode: notImplementedStatement
+	});
+});
+
+//#endregion
 //#region src/generators/schema.ts
 var import_lib$3 = /* @__PURE__ */ __toESM(require_lib(), 1);
 const equivalentType = (type) => ({
 	typeDecoded: type,
 	typeEncoded: type
 });
-function defaultParseJson(options) {
-	return (expression) => options.transformer({
-		encoded: options.schema.string,
-		decoded: expression,
-		decode: import_lib$3.blockStatement([import_lib$3.tryStatement(import_lib$3.blockStatement([import_lib$3.returnStatement(import_lib$3.callExpression(import_lib$3.memberExpression(import_lib$3.identifier("JSON"), import_lib$3.identifier("parse")), [import_lib$3.identifier("from")]))]), import_lib$3.catchClause(Object.assign(import_lib$3.identifier("error"), { typeAnnotation: import_lib$3.tsTypeAnnotation(import_lib$3.tsUnknownKeyword()) }), options.transformerCatch(import_lib$3.identifier("error"))))]),
-		encode: import_lib$3.callExpression(import_lib$3.memberExpression(import_lib$3.identifier("JSON"), import_lib$3.identifier("stringify")), [import_lib$3.identifier("from")])
-	});
-}
+const resolveSchema = Effect.fn(function* (schema) {
+	const ctx = yield* DocumentContext;
+	let resolvedSchema = schema;
+	for (let i = 0; i < 10; i++) {
+		if (!("$ref" in resolvedSchema)) return resolvedSchema;
+		const ref = resolvedSchema.$ref;
+		if (!ref.startsWith("#/components/schemas/")) return yield* new NotImplementedError({ message: `$ref ${ref}` });
+		const schemaName = ref.slice(21);
+		const nextSchema = ctx.document.components?.schemas?.[schemaName];
+		if (!nextSchema) return yield* new NotImplementedError({ message: `Missing $ref ${ref}` });
+		resolvedSchema = nextSchema;
+	}
+	return yield* new NotImplementedError({ message: `Too many $ref in schema` });
+});
+const stringLiteralOrIdentifier = (value) => {
+	if (value.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) return import_lib$3.identifier(value);
+	return import_lib$3.stringLiteral(value);
+};
+const memberExpressionWithStringProperty = (object, property) => {
+	if (property.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) return import_lib$3.memberExpression(object, import_lib$3.identifier(property));
+	return import_lib$3.memberExpression(object, import_lib$3.stringLiteral(property), true);
+};
 function createSchemaGenerator(options) {
 	const ensureStandardParametersSchema = Effect.fn(function* () {
 		const ctx = yield* DocumentContext;
 		if (!ctx.schemas.has("ParametersSchema")) ctx.schemas.set("ParametersSchema", [import_lib$3.exportNamedDeclaration(import_lib$3.variableDeclaration("const", [import_lib$3.variableDeclarator(import_lib$3.identifier("ParametersSchema"), import_lib$3.callExpression(options.schema.object, [import_lib$3.objectExpression([
-			import_lib$3.objectProperty(import_lib$3.identifier("query"), options.modifiers.optional(import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("URLSearchParams")]))),
+			import_lib$3.objectProperty(import_lib$3.identifier("path"), options.schema.string),
 			import_lib$3.objectProperty(import_lib$3.identifier("headers"), options.modifiers.optional(import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Headers")]))),
-			import_lib$3.objectProperty(import_lib$3.identifier("path"), options.modifiers.optional(options.schema.record(options.schema.string, options.schema.string))),
-			import_lib$3.objectProperty(import_lib$3.identifier("body"), options.modifiers.optional(options.schema.union([options.schema.string, import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Blob")])])))
+			import_lib$3.objectProperty(import_lib$3.identifier("body"), options.modifiers.optional(options.schema.union([
+				options.schema.string,
+				import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Blob")]),
+				import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("FormData")]),
+				import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("URLSearchParams")])
+			])))
 		])]))]))]);
 		return import_lib$3.identifier("ParametersSchema");
 	});
@@ -89,11 +204,16 @@ function createSchemaGenerator(options) {
 			};
 		}
 		if (schema.enum) {
-			const unsupportedEnumValue = schema.enum.find((i) => typeof i !== "string");
+			const unsupportedEnumValue = schema.enum.find((i) => typeof i !== "string" && typeof i !== "number" && typeof i !== "boolean" && i !== null);
 			if (unsupportedEnumValue !== void 0) return yield* new NotImplementedError({ message: `Unsupported 'enum' value: ${JSON.stringify(unsupportedEnumValue)}` });
+			const getLiteral = (value) => {
+				if (typeof value === "number") return import_lib$3.numericLiteral(value);
+				if (typeof value === "boolean") return import_lib$3.booleanLiteral(value);
+				return import_lib$3.stringLiteral(value);
+			};
 			return {
-				expression: options.schema.enum(schema.enum.map((e) => import_lib$3.stringLiteral(e))),
-				...equivalentType(import_lib$3.tsUnionType(schema.enum.map((e) => import_lib$3.tsLiteralType(import_lib$3.stringLiteral(e))))),
+				expression: options.schema.enum(schema.enum.map((e) => e === null ? import_lib$3.nullLiteral() : getLiteral(e))),
+				...equivalentType(import_lib$3.tsUnionType(schema.enum.map((e) => e === null ? import_lib$3.tsNullKeyword() : import_lib$3.tsLiteralType(getLiteral(e))))),
 				typeMeta
 			};
 		}
@@ -104,6 +224,11 @@ function createSchemaGenerator(options) {
 				typeMeta
 			};
 			case "string": {
+				if (schema.format === "binary") return {
+					expression: import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Blob")]),
+					...equivalentType(import_lib$3.tsTypeReference(import_lib$3.identifier("Blob"))),
+					typeMeta
+				};
 				let expression = {
 					expression: options.schema.string,
 					...equivalentType(import_lib$3.tsStringKeyword()),
@@ -137,7 +262,7 @@ function createSchemaGenerator(options) {
 						decodedMember.optional = true;
 						encodedMember.optional = true;
 					}
-					const objectProperty = import_lib$3.objectProperty(import_lib$3.identifier(propertyKey), propertySchema.expression);
+					const objectProperty = import_lib$3.objectProperty(stringLiteralOrIdentifier(propertyKey), propertySchema.expression);
 					if (property.description) import_lib$3.addComment(objectProperty, "leading", `* ${property.description}`);
 					object.properties.push(objectProperty);
 					objectTypeDecoded.members.push(decodedMember);
@@ -220,44 +345,40 @@ function createSchemaGenerator(options) {
 		};
 		return expressions[0];
 	});
-	const ensureParametersSchema = Effect.fn(function* (operationKey, method) {
+	const ensureParametersSchema = Effect.fn(function* (operationKey, method, path) {
 		const ctx = yield* DocumentContext;
 		const identifier = import_lib$3.identifier(`${operationKey.upper}_Parameters`);
 		const object = import_lib$3.objectExpression([]);
 		const queryArray = import_lib$3.arrayExpression([]);
-		const pathObject = import_lib$3.objectExpression([]);
+		const pathParameters = {};
 		const headerArray = import_lib$3.arrayExpression([]);
 		let hasBody = false;
-		for (const parameter of method.parameters ?? []) {
-			if ("$ref" in parameter) return yield* new NotImplementedError({ message: "$ref in parameter" });
+		for (let parameter of method.parameters ?? []) {
+			if ("$ref" in parameter) {
+				const newParameter = ctx.document.components?.parameters?.[parameter.$ref.slice(24)];
+				if (newParameter) parameter = newParameter;
+				else return yield* new NotImplementedError({ message: "Unresolved $ref in parameter" });
+				if ("$ref" in parameter) return yield* new NotImplementedError({ message: "$ref in parameter" });
+			}
 			if (!parameter.schema) return yield* new NotImplementedError({ message: "parameter without schema" });
 			let expression = (yield* ensureSchema(parameter.schema)).expression;
 			if (!parameter.required) expression = options.modifiers.optional(expression);
-			const objectProperty = import_lib$3.objectProperty(import_lib$3.identifier(parameter.name), expression);
+			const objectProperty = import_lib$3.objectProperty(stringLiteralOrIdentifier(parameter.name), expression);
 			if (parameter.description) import_lib$3.addComment(objectProperty, "leading", `* ${parameter.description}`);
 			object.properties.push(objectProperty);
 			if (parameter.in === "query") {
-				const param = import_lib$3.memberExpression(import_lib$3.identifier("from"), import_lib$3.identifier(parameter.name));
-				if ("type" in parameter.schema && parameter.schema.type === "array") queryArray.elements.push(import_lib$3.spreadElement(import_lib$3.logicalExpression("??", Object.assign(import_lib$3.optionalCallExpression(import_lib$3.optionalMemberExpression(param, import_lib$3.identifier("map"), false, true), [import_lib$3.arrowFunctionExpression([import_lib$3.identifier("value")], import_lib$3.arrayExpression([import_lib$3.stringLiteral(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [import_lib$3.identifier("value")])]))], false), { typeParameters: import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeReference(import_lib$3.identifier("[string, string]"))]) }), import_lib$3.arrayExpression([]))));
+				const param = memberExpressionWithStringProperty(import_lib$3.identifier("from"), parameter.name);
+				if ("type" in parameter.schema && parameter.schema.type === "array") queryArray.elements.push(import_lib$3.spreadElement(import_lib$3.logicalExpression("??", Object.assign(import_lib$3.optionalCallExpression(import_lib$3.optionalMemberExpression(param, import_lib$3.identifier("map"), false, true), [import_lib$3.arrowFunctionExpression([import_lib$3.identifier("value")], import_lib$3.arrayExpression([import_lib$3.stringLiteral(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [import_lib$3.identifier("value")])]))], false), { typeParameters: import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTupleType([import_lib$3.tsStringKeyword(), import_lib$3.tsStringKeyword()])]) }), import_lib$3.arrayExpression([]))));
 				else queryArray.elements.push(import_lib$3.arrayExpression([import_lib$3.stringLiteral(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [param])]));
-			} else if (parameter.in === "path") pathObject.properties.push(import_lib$3.objectProperty(import_lib$3.identifier(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [import_lib$3.memberExpression(import_lib$3.identifier("from"), import_lib$3.identifier(parameter.name))])));
-			else if (parameter.in === "header") headerArray.elements.push(import_lib$3.arrayExpression([import_lib$3.stringLiteral(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [import_lib$3.memberExpression(import_lib$3.identifier("from"), import_lib$3.identifier(parameter.name))])]));
+			} else if (parameter.in === "path") pathParameters[parameter.name] = memberExpressionWithStringProperty(import_lib$3.identifier("from"), parameter.name);
+			else if (parameter.in === "header") headerArray.elements.push(import_lib$3.arrayExpression([import_lib$3.stringLiteral(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [memberExpressionWithStringProperty(import_lib$3.identifier("from"), parameter.name)])]));
 			else return yield* new NotImplementedError({ message: `parameter in ${parameter.in}` });
 		}
-		body: if (method.requestBody) {
-			if ("$ref" in method.requestBody) return yield* new NotImplementedError({ message: "$ref in requestBody" });
-			for (const contentKey in method.requestBody.content) {
-				hasBody = true;
-				const schema = method.requestBody.content[contentKey]?.schema;
-				if (!!schema && contentKey === "application/json") {
-					object.properties.push(import_lib$3.objectProperty(import_lib$3.identifier("data"), (options.builtins.parseJson ?? defaultParseJson(options))((yield* ensureSchema(schema)).expression)));
-					break body;
-				} else if (contentKey === "application/octet-stream") {
-					object.properties.push(import_lib$3.objectProperty(import_lib$3.identifier("data"), import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Blob")])));
-					break body;
-				}
-			}
-			return yield* new NotImplementedError({ message: `No supported requestBody type (${Object.keys(method.requestBody.content).join(", ")})` });
+		const body = yield* requestBodySchema(operationKey, method);
+		if (body) {
+			hasBody = true;
+			object.properties.push(import_lib$3.objectProperty(import_lib$3.identifier("data"), body.data));
+			headerArray.elements.push(...body.headers);
 		}
 		const decodedSchema = import_lib$3.callExpression(options.schema.object, [object]);
 		const transform = options.transformer({
@@ -265,9 +386,8 @@ function createSchemaGenerator(options) {
 			decoded: decodedSchema,
 			decode: import_lib$3.blockStatement([import_lib$3.throwStatement(import_lib$3.newExpression(import_lib$3.identifier("Error"), [import_lib$3.stringLiteral("Not implemented")]))]),
 			encode: import_lib$3.objectExpression([
-				...queryArray.elements.length ? [import_lib$3.objectProperty(import_lib$3.identifier("query"), import_lib$3.newExpression(import_lib$3.identifier("URLSearchParams"), [queryArray]))] : [],
-				...pathObject.properties.length ? [import_lib$3.objectProperty(import_lib$3.identifier("path"), pathObject)] : [],
-				...headerArray.elements.length ? [import_lib$3.objectProperty(import_lib$3.identifier("header"), import_lib$3.newExpression(import_lib$3.identifier("Headers"), [headerArray]))] : [],
+				import_lib$3.objectProperty(import_lib$3.identifier("path"), generatePathExpression(path, pathParameters, queryArray.elements.length ? import_lib$3.newExpression(import_lib$3.identifier("URLSearchParams"), [queryArray]) : null)),
+				...headerArray.elements.length ? [import_lib$3.objectProperty(import_lib$3.identifier("headers"), import_lib$3.newExpression(import_lib$3.identifier("Headers"), [headerArray]))] : [],
 				...hasBody ? [import_lib$3.objectProperty(import_lib$3.identifier("body"), import_lib$3.memberExpression(import_lib$3.identifier("from"), import_lib$3.identifier("data")))] : []
 			])
 		});
@@ -277,16 +397,65 @@ function createSchemaGenerator(options) {
 			typeReference: import_lib$3.tsTypeReference(options.types.typeDecoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(identifier)]))
 		};
 	});
+	const requestBodySchema = Effect.fn(function* (operationKey, method) {
+		if (!method.requestBody) return null;
+		if ("$ref" in method.requestBody) return yield* new NotImplementedError({ message: "$ref in requestBody" });
+		let hasBody = false;
+		for (const contentType in method.requestBody.content) {
+			hasBody = true;
+			const schema = method.requestBody.content[contentType]?.schema;
+			if (contentType === "application/json") {
+				if (!schema) continue;
+				return {
+					headers: [import_lib$3.arrayExpression([import_lib$3.stringLiteral("Content-Type"), import_lib$3.stringLiteral("application/json")])],
+					data: yield* generateJsonRequestCodec(options, yield* resolveSchema(schema), (yield* ensureSchema(schema)).expression)
+				};
+			} else if (contentType === "multipart/form-data") {
+				if (!schema) continue;
+				return {
+					headers: [],
+					data: yield* generateFormDataRequestCodec(options, yield* resolveSchema(schema), (yield* ensureSchema(schema)).expression)
+				};
+			} else {
+				if (schema && ("$ref" in schema || schema.type !== "string" && schema.format !== "binary")) continue;
+				return {
+					headers: [import_lib$3.arrayExpression([import_lib$3.stringLiteral("Content-Type"), import_lib$3.stringLiteral(contentType)])],
+					data: import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Blob")])
+				};
+			}
+		}
+		if (!hasBody) return null;
+		return yield* new NotImplementedError({ message: `No supported requestBody type (${Object.keys(method.requestBody.content).join(", ")}) in ${operationKey.upper}` });
+	});
+	const responseSchema = Effect.fn(function* (content) {
+		if (content) {
+			for (const [format, formatContent] of Object.entries(content)) if (format === "application/json") {
+				if (!formatContent.schema) continue;
+				const schema = formatContent.schema;
+				const decodedSchema = (yield* ensureSchema(schema)).expression;
+				return yield* generateJsonResponseCodec(options, yield* resolveSchema(schema), decodedSchema);
+			}
+		}
+		return yield* generateBlobResponseCodec(options);
+	});
 	const ensureResponseSchema = Effect.fn(function* (operationKey, method) {
 		const ctx = yield* DocumentContext;
-		if (!method.responses?.["200"]) return null;
-		if ("$ref" in method.responses["200"]) return yield* new NotImplementedError({ message: "$ref in response" });
-		if (!method.responses["200"].content) return null;
-		if (!method.responses["200"].content["application/json"]?.schema) return yield* new NotImplementedError({ message: `response without 'application/json' content schema in ${operationKey.upper}` });
-		const schema = method.responses["200"].content["application/json"].schema;
+		let transform;
+		if (!method.responses?.["200"]) transform = yield* responseSchema(void 0);
+		else {
+			let response;
+			if ("$ref" in method.responses["200"]) {
+				const ref = method.responses["200"].$ref;
+				if (!ref.startsWith("#/components/responses/")) return yield* new NotImplementedError({ message: `$ref ${ref} in response in ${operationKey.upper}` });
+				const responseName = ref.slice(23);
+				const newResponse = ctx.document.components?.responses?.[responseName];
+				if (!newResponse) return yield* new NotImplementedError({ message: `Missing $ref ${ref} in response in ${operationKey.upper}` });
+				if ("$ref" in newResponse) return yield* new NotImplementedError({ message: `$ref in $ref in response in ${operationKey.upper}` });
+				response = newResponse;
+			} else response = method.responses["200"];
+			transform = yield* responseSchema(response.content);
+		}
 		const identifier = import_lib$3.identifier(`${operationKey.upper}_Response`);
-		const decodedSchema = (yield* ensureSchema(schema)).expression;
-		const transform = (options.builtins.parseJson ?? defaultParseJson(options))(decodedSchema);
 		ctx.schemas.set(identifier.name, [import_lib$3.exportNamedDeclaration(import_lib$3.variableDeclaration("const", [import_lib$3.variableDeclarator(identifier, transform)]))]);
 		return {
 			expression: identifier,
@@ -296,17 +465,25 @@ function createSchemaGenerator(options) {
 	const processSchema = Effect.fn(function* (schema) {
 		if (options.includeSchemas ?? true) yield* ensureSchema(schema);
 	});
-	const processOperation = Effect.fn(function* (operationKey, _path, _method, operation) {
+	const processOperation = Effect.fn(function* (operationKey, path, _method, operation) {
 		if (options.includeOperations) {
-			yield* ensureParametersSchema(operationKey, operation);
+			yield* ensureParametersSchema(operationKey, operation, path);
 			yield* ensureResponseSchema(operationKey, operation);
 		}
 	});
+	const decodeResponse = Effect.fn(function* (schema, response) {
+		return options.methods.decode(schema, response);
+	});
+	const encodeParameters = Effect.fn(function* (schema, response) {
+		return options.methods.encode(schema, response);
+	});
 	return {
 		processSchema,
 		processOperation,
 		ensureParametersSchema,
 		ensureResponseSchema,
+		decodeResponse,
+		encodeParameters,
 		get schemaType() {
 			return options.types.schema;
 		}
@@ -346,26 +523,37 @@ const createEffectSchemaGenerator = (options) => ({
 			null: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Null")),
 			unknown: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Unknown"))
 		},
-		transformer: ({ encoded, decoded, decode, encode }) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("transform")), [
-			encoded,
-			decoded,
-			import_lib$2.objectExpression([
-				import_lib$2.objectProperty(import_lib$2.identifier("strict"), import_lib$2.booleanLiteral(true)),
-				import_lib$2.objectProperty(import_lib$2.identifier("decode"), import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], decode)),
-				import_lib$2.objectProperty(import_lib$2.identifier("encode"), import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], encode))
-			])
-		]),
+		transformer: ({ encoded, decoded, decode, decodeAsync, encode, encodeAsync }) => {
+			let decodeFn;
+			let encodeFn;
+			if (decodeAsync || encodeAsync) {
+				decodeFn = import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Effect"), import_lib$2.identifier("promise")), [import_lib$2.arrowFunctionExpression([], decode, true)]));
+				encodeFn = import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Effect"), import_lib$2.identifier("promise")), [import_lib$2.arrowFunctionExpression([], encode, true)]));
+			} else {
+				decodeFn = import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], decode);
+				encodeFn = import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], encode);
+			}
+			return import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier(decodeAsync || encodeAsync ? "transformOrFail" : "transform")), [
+				encoded,
+				decoded,
+				import_lib$2.objectExpression([
+					import_lib$2.objectProperty(import_lib$2.identifier("strict"), import_lib$2.booleanLiteral(true)),
+					import_lib$2.objectProperty(import_lib$2.identifier("decode"), decodeFn),
+					import_lib$2.objectProperty(import_lib$2.identifier("encode"), encodeFn)
+				])
+			]);
+		},
 		transformerCatch: (expression) => import_lib$2.blockStatement([import_lib$2.throwStatement(expression)]),
-		builtins: { parseJson: (expression) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("parseJson")), [expression]) },
 		methods: {
-			encode: (schema, value) => import_lib$2.callExpression(import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("encodeSync")), [schema]), [value]),
-			decode: (schema, value) => import_lib$2.callExpression(import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("decodeSync")), [schema]), [value]),
-			parse: (schema, value) => import_lib$2.callExpression(import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("decodeUnknownSync")), [schema]), [value])
+			encode: (schema, value) => import_lib$2.callExpression(import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("encodePromise")), [schema]), [value]),
+			decode: (schema, value) => import_lib$2.callExpression(import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("decodePromise")), [schema]), [value]),
+			parse: (schema, value) => import_lib$2.callExpression(import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("decodeUnknownPromise")), [schema]), [value])
 		},
 		supportsImmutability: true
 	}),
 	initialize: Effect.fn(function* () {
 		yield* ensureNamespaceImport("Schema", "effect/Schema");
+		yield* ensureImport("Effect", "effect");
 	})
 });
 
@@ -405,21 +593,20 @@ const createZodSchemaGenerator = ({ mini = false,...options }) => {
 				null: import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("null")), []),
 				unknown: import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("unknown")), [])
 			},
-			transformer: ({ encoded, decoded, decode, encode }) => import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("codec")), [
+			transformer: ({ encoded, decoded, decode, decodeAsync, encode, encodeAsync }) => import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("codec")), [
 				encoded,
 				decoded,
-				import_lib$1.objectExpression([import_lib$1.objectProperty(import_lib$1.identifier("decode"), import_lib$1.arrowFunctionExpression([import_lib$1.identifier("from"), import_lib$1.identifier("ctx")], decode)), import_lib$1.objectProperty(import_lib$1.identifier("encode"), import_lib$1.arrowFunctionExpression([import_lib$1.identifier("from"), import_lib$1.identifier("ctx")], encode))])
+				import_lib$1.objectExpression([import_lib$1.objectProperty(import_lib$1.identifier("decode"), import_lib$1.arrowFunctionExpression([import_lib$1.identifier("from"), import_lib$1.identifier("ctx")], decode, decodeAsync)), import_lib$1.objectProperty(import_lib$1.identifier("encode"), import_lib$1.arrowFunctionExpression([import_lib$1.identifier("from"), import_lib$1.identifier("ctx")], encode, encodeAsync))])
 			]),
 			transformerCatch: (expression) => import_lib$1.blockStatement([import_lib$1.expressionStatement(import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.memberExpression(import_lib$1.identifier("ctx"), import_lib$1.identifier("issues")), import_lib$1.identifier("push")), [import_lib$1.objectExpression([
 				import_lib$1.objectProperty(import_lib$1.identifier("code"), import_lib$1.stringLiteral("custom")),
 				import_lib$1.objectProperty(import_lib$1.identifier("input"), import_lib$1.identifier("from")),
 				import_lib$1.objectProperty(import_lib$1.identifier("message"), import_lib$1.memberExpression(import_lib$1.tsAsExpression(expression, import_lib$1.tsTypeReference(import_lib$1.identifier("Error"))), import_lib$1.identifier("message")))
 			])])), import_lib$1.returnStatement(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("NEVER")))]),
-			builtins: {},
 			methods: {
-				encode: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("encode")), [schema, value]),
-				decode: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("decode")), [schema, value]),
-				parse: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("parse")), [schema, value])
+				encode: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("encodeAsync")), [schema, value]),
+				decode: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("decodeAsync")), [schema, value]),
+				parse: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("parseAsync")), [schema, value])
 			},
 			supportsImmutability: false
 		}),
@@ -436,22 +623,22 @@ function createReactQueryClientGenerator(options) {
 	const ensureApi = Effect.fn(function* () {
 		const ctx = yield* DocumentContext;
 		if (!ctx.schemas.has("Api")) {
-			const makeRequest = import_lib.identifier("makeRequest");
-			const makeRequestOptions = import_lib.identifier("options");
-			makeRequestOptions.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsTypeLiteral([
+			const fetch = import_lib.identifier("fetch");
+			const fetchPath = import_lib.identifier("path");
+			fetchPath.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsStringKeyword());
+			const fetchOptions = import_lib.identifier("options");
+			fetchOptions.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsTypeLiteral([
 				import_lib.tsPropertySignature(import_lib.identifier("method"), import_lib.tsTypeAnnotation(import_lib.tsStringKeyword())),
-				import_lib.tsPropertySignature(import_lib.identifier("path"), import_lib.tsTypeAnnotation(import_lib.tsStringKeyword())),
-				import_lib.tsPropertySignature(import_lib.identifier("parametersSchema"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(options.schema.schemaType, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeReference(import_lib.identifier("TParams")), import_lib.tsTypeLiteral([
-					Object.assign(import_lib.tsPropertySignature(import_lib.identifier("query"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("URLSearchParams")))), { optional: true }),
-					Object.assign(import_lib.tsPropertySignature(import_lib.identifier("body"), import_lib.tsTypeAnnotation(import_lib.tsUnionType([import_lib.tsStringKeyword(), import_lib.tsTypeReference(import_lib.identifier("Blob"))]))), { optional: true }),
-					Object.assign(import_lib.tsPropertySignature(import_lib.identifier("headers"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("Headers")))), { optional: true }),
-					Object.assign(import_lib.tsPropertySignature(import_lib.identifier("path"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("Record<string, string>")))), { optional: true })
-				])])))),
-				import_lib.tsPropertySignature(import_lib.identifier("parameters"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("TParams")))),
-				Object.assign(import_lib.tsPropertySignature(import_lib.identifier("responseSchema"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(options.schema.schemaType, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeReference(import_lib.identifier("TResponse")), import_lib.tsStringKeyword()])))), { optional: true })
+				Object.assign(import_lib.tsPropertySignature(import_lib.identifier("headers"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("Headers")))), { optional: true }),
+				Object.assign(import_lib.tsPropertySignature(import_lib.identifier("body"), import_lib.tsTypeAnnotation(import_lib.tsUnionType([
+					import_lib.tsTypeReference(import_lib.identifier("string")),
+					import_lib.tsTypeReference(import_lib.identifier("Blob")),
+					import_lib.tsTypeReference(import_lib.identifier("FormData")),
+					import_lib.tsTypeReference(import_lib.identifier("URLSearchParams"))
+				]))), { optional: true })
 			]));
-			makeRequest.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsFunctionType(import_lib.tsTypeParameterDeclaration([import_lib.tsTypeParameter(null, null, "TParams"), import_lib.tsTypeParameter(null, null, "TResponse")]), [makeRequestOptions], import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier(options.responseGeneric ? `Promise<${(yield* ensureImport(options.responseGeneric.name, options.responseGeneric.from)).name}<TResponse>>` : "Promise<TResponse>")))));
-			ctx.schemas.set("Api", [import_lib.exportNamedDeclaration(import_lib.classDeclaration(import_lib.identifier("Api"), null, import_lib.classBody([import_lib.classPrivateProperty(import_lib.privateName(makeRequest)), import_lib.classMethod("constructor", import_lib.identifier("constructor"), [makeRequest], import_lib.blockStatement([import_lib.expressionStatement(import_lib.assignmentExpression("=", import_lib.memberExpression(import_lib.thisExpression(), import_lib.privateName(makeRequest)), makeRequest))]))])))]);
+			fetch.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsFunctionType(null, [fetchPath, fetchOptions], import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("Promise"), import_lib.tsTypeParameterInstantiation([import_lib.tsTypeReference(import_lib.identifier("Response"))])))));
+			ctx.schemas.set("Api", [import_lib.exportNamedDeclaration(import_lib.classDeclaration(import_lib.identifier("Api"), null, import_lib.classBody([import_lib.classPrivateProperty(import_lib.privateName(fetch)), import_lib.classMethod("constructor", import_lib.identifier("constructor"), [fetch], import_lib.blockStatement([import_lib.expressionStatement(import_lib.assignmentExpression("=", import_lib.memberExpression(import_lib.thisExpression(), import_lib.privateName(fetch)), fetch))]))])))]);
 		}
 		return ctx.schemas.get("Api")[0].declaration.body;
 	});
@@ -461,20 +648,21 @@ function createReactQueryClientGenerator(options) {
 			if (options.schema.initialize) yield* options.schema.initialize();
 		}),
 		processOperation: Effect.fn(function* (operationKey, path, method, operation) {
-			yield* DocumentContext;
-			const parametersSchema = yield* options.schema.ensureParametersSchema(operationKey, operation);
+			const parametersSchema = yield* options.schema.ensureParametersSchema(operationKey, operation, path);
 			const responseSchema = yield* options.schema.ensureResponseSchema(operationKey, operation);
 			const parameters = import_lib.identifier("parameters");
 			parameters.typeAnnotation = import_lib.tsTypeAnnotation(parametersSchema.typeReference);
-			const isMutation = method !== "get";
-			const fnBody = import_lib.awaitExpression(import_lib.callExpression(import_lib.memberExpression(import_lib.thisExpression(), import_lib.privateName(import_lib.identifier("makeRequest"))), [import_lib.objectExpression([
+			const isMutation = method !== "get" && method !== "head" && method !== "options";
+			const fetchCall = import_lib.awaitExpression(import_lib.callExpression(import_lib.memberExpression(import_lib.thisExpression(), import_lib.privateName(import_lib.identifier("fetch"))), [import_lib.memberExpression(import_lib.identifier("params"), import_lib.identifier("path")), import_lib.objectExpression([
 				import_lib.objectProperty(import_lib.identifier("method"), import_lib.stringLiteral(method)),
-				import_lib.objectProperty(import_lib.identifier("path"), import_lib.stringLiteral(path)),
-				import_lib.objectProperty(import_lib.identifier("parametersSchema"), parametersSchema.expression, false, true),
-				import_lib.objectProperty(import_lib.identifier("parameters"), parameters),
-				...responseSchema ? [import_lib.objectProperty(import_lib.identifier("responseSchema"), responseSchema.expression)] : []
+				import_lib.objectProperty(import_lib.identifier("headers"), import_lib.memberExpression(import_lib.identifier("params"), import_lib.identifier("headers"))),
+				import_lib.objectProperty(import_lib.identifier("body"), import_lib.memberExpression(import_lib.identifier("params"), import_lib.identifier("body")))
 			])]));
-			const doMethod = import_lib.classMethod("method", import_lib.identifier(operationKey.lower), [parameters], import_lib.blockStatement([import_lib.returnStatement(fnBody)]), false, false, false, true);
+			const doMethod = import_lib.classMethod("method", import_lib.identifier(operationKey.lower), [parameters], import_lib.blockStatement([
+				import_lib.variableDeclaration("const", [import_lib.variableDeclarator(import_lib.identifier("params"), import_lib.awaitExpression(yield* options.schema.encodeParameters(parametersSchema.expression, import_lib.identifier("parameters"))))]),
+				import_lib.variableDeclaration("const", [import_lib.variableDeclarator(import_lib.identifier("response"), fetchCall)]),
+				import_lib.returnStatement(import_lib.awaitExpression(yield* options.schema.decodeResponse(responseSchema.expression, import_lib.identifier("response"))))
+			]), false, false, false, true);
 			const queryMethod = import_lib.classMethod("method", import_lib.identifier(operationKey.lower + (isMutation ? "Mutation" : "Query")), isMutation ? [] : [parameters], import_lib.blockStatement([import_lib.returnStatement(import_lib.callExpression(yield* ensureImport(isMutation ? "mutationOptions" : "queryOptions", "@tanstack/react-query"), [import_lib.objectExpression([...isMutation ? [] : [import_lib.objectProperty(import_lib.identifier("queryKey"), import_lib.tsAsExpression(import_lib.arrayExpression([import_lib.stringLiteral(operationKey.upper), parameters]), import_lib.tsTypeReference(yield* ensureImport("QueryKey", "@tanstack/react-query", true))))], import_lib.objectProperty(import_lib.identifier(isMutation ? "mutationFn" : "queryFn"), import_lib.arrowFunctionExpression(isMutation ? [parameters] : [], import_lib.callExpression(import_lib.memberExpression(import_lib.thisExpression(), import_lib.identifier(operationKey.lower)), [parameters]), true))])]))]));
 			const commentLines = [];
 			if (operation.summary) commentLines.push(`### ${operation.summary}`);