@spec2ts/openapi-client 4.0.0 → 4.0.1

package/dist/bin/oapi2tsclient.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as usage, n as describe, r as handler, t as builder } from "../command-Djig04Ub.mjs";
+import { i as usage, n as describe, r as handler, t as builder } from "../command-C4XUi5ys.mjs";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 //#region src/bin/oapi2tsclient.ts

package/dist/cli/index.d.mts

@@ -1,4 +1,4 @@
-import { t as OApiGeneratorOptions } from "../openapi-generator-DfC4jH9J.mjs";
+import { t as OApiGeneratorOptions } from "../openapi-generator-B6yW0z4d.mjs";
 import { Argv } from "yargs";
 //#region src/cli/command.d.ts
 interface BuildClientFromOpenApiOptions extends OApiGeneratorOptions {

package/dist/cli/index.mjs

@@ -1,2 +1,2 @@
-import { i as usage, n as describe, r as handler, t as builder } from "../command-Djig04Ub.mjs";
+import { i as usage, n as describe, r as handler, t as builder } from "../command-C4XUi5ys.mjs";
 export { builder, describe, handler, usage };

package/dist/{command-Djig04Ub.mjs → command-C4XUi5ys.mjs}

@@ -1,7 +1,7 @@
-import { n as generateClientFromFile } from "./openapi-generator-DwzcjKrv.mjs";
-import * as path from "path";
+import { n as generateClientFromFile } from "./openapi-generator-IB_huQ-a.mjs";
 import { cli, printer } from "@spec2ts/core";
-import { promises } from "fs";
+import path from "node:path";
+import fs from "node:fs/promises";
 //#region src/cli/command.ts
 const usage = "$0 <input..>";
 const describe = "Generate TypeScript HTTP client from OpenAPI specification";
@@ -137,7 +137,7 @@ async function generatePackage(output, options) {
 		pkg.devDependencies["@types/node"] = "*";
 	}
 	if (options.packagePrivate) pkg.private = options.packagePrivate;
-	await promises.writeFile(path.join(outputDir, "package.json"), JSON.stringify(pkg, null, 2), "utf8");
+	await fs.writeFile(path.join(outputDir, "package.json"), JSON.stringify(pkg, null, 2), "utf8");
 }
 //#endregion
 export { usage as i, describe as n, handler as r, builder as t };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { i as generateClientFromFile, n as SeparatedClientResult, r as generateClient, t as OApiGeneratorOptions } from "./openapi-generator-DfC4jH9J.mjs";
+import { i as generateClientFromFile, n as SeparatedClientResult, r as generateClient, t as OApiGeneratorOptions } from "./openapi-generator-B6yW0z4d.mjs";
 export { OApiGeneratorOptions, SeparatedClientResult, generateClient, generateClientFromFile };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { n as generateClientFromFile, t as generateClient } from "./openapi-generator-DwzcjKrv.mjs";
+import { n as generateClientFromFile, t as generateClient } from "./openapi-generator-IB_huQ-a.mjs";
 export { generateClient, generateClientFromFile };

package/dist/{openapi-generator-DfC4jH9J.d.mts → openapi-generator-B6yW0z4d.d.mts}

@@ -1,5 +1,5 @@
 import { ParserOptions } from "@spec2ts/jsonschema";
-import * as ts from "typescript";
+import ts from "typescript";
 import { OpenAPIObject } from "openapi3-ts/oas31";
 //#region src/lib/openapi-generator.d.ts
 interface OApiGeneratorOptions extends ParserOptions {

package/dist/openapi-generator-IB_huQ-a.mjs

@@ -0,0 +1,414 @@
+import $RefParser from "@apidevtools/json-schema-ref-parser";
+import * as core from "@spec2ts/core";
+import { createContext, getTypeFromSchema, isReference, resolveReference } from "@spec2ts/jsonschema";
+import { getOperationName, getResponseName, parseReference } from "@spec2ts/openapi";
+import path from "node:path";
+import ts from "typescript";
+//#region src/lib/util.ts
+function camelCase(str) {
+	const words = str.match(/[A-Z\xC0-\xD6\xD8-\xDE_$]?[a-z\xDF-\xF6\xF8-\xFF_$]+|[A-Z\xC0-\xD6\xD8-\xDE_$]+(?![a-z\xDF-\xF6\xF8-\xFF_$])|\d+/g);
+	if (!words) return "";
+	let result = "";
+	const len = words.length;
+	for (let i = 0; i < len; i++) {
+		let tmp = words[i].toLowerCase();
+		if (i !== 0) tmp = tmp[0].toUpperCase() + tmp.substr(1);
+		result += tmp;
+	}
+	return result;
+}
+//#endregion
+//#region src/lib/core-parser.ts
+const methods = [
+	"GET",
+	"PUT",
+	"POST",
+	"DELETE",
+	"OPTIONS",
+	"HEAD",
+	"PATCH",
+	"TRACE"
+];
+const contentTypes = {
+	"*/*": "json",
+	"application/json": "json",
+	"application/x-www-form-urlencoded": "form",
+	"multipart/form-data": "multipart"
+};
+function parseOperation(path, item, method, operation, context) {
+	const result = {
+		name: getOperationVar(method, path, operation.operationId, context),
+		paramsVars: {},
+		args: [],
+		query: [],
+		header: [],
+		response: core.keywordType.void
+	};
+	parseArgs(result, item, operation, context);
+	parseResponses(result, path, method, operation, context);
+	return result;
+}
+function parseArgs(result, item, operation, context) {
+	parseParameters(result, item, operation, context);
+	if (operation.requestBody) parseRequestBody(result, operation.requestBody, context);
+	result.args.push(core.createParameter("options", {
+		type: ts.factory.createTypeReferenceNode("RequestOptions", void 0),
+		questionToken: true
+	}));
+}
+function parseResponses(result, path, method, operation, context) {
+	const operationName = getOperationName(method, path, operation.operationId, context);
+	if (operation.responses) {
+		result.response = getTypeFromResponses(operationName, operation.responses, context);
+		result.responseJSON = isJSONResponse(operation.responses, context);
+		result.responseVoid = result.response === core.keywordType.void;
+	} else {
+		result.response = core.keywordType.unknown;
+		result.responseJSON = false;
+		result.responseVoid = false;
+	}
+}
+function parseParameters(result, item, operation, context) {
+	const parameters = fixDeepObjects([...resolveReferences(item.parameters, context), ...resolveReferences(operation.parameters, context)]);
+	result.query = parameters.filter((p) => p.in === "query");
+	result.header = parameters.filter((p) => p.in === "header");
+	const argNames = result.paramsVars = createParametersNames(parameters);
+	let objectBindingParams = parameters;
+	if (context.options.inlineRequired) {
+		const [required, optional] = splitParameters(parameters);
+		objectBindingParams = optional;
+		required.forEach((p) => {
+			result.args.push(core.createParameter(argNames[p.name], { type: getTypeFromSchema(p.schema, context) }));
+		});
+	}
+	if (!objectBindingParams.length) return;
+	result.args.push(core.createParameter(core.createObjectBinding(objectBindingParams.map(({ name }) => ({ name: argNames[name] }))), {
+		initializer: objectBindingParams.some((p) => p.required) ? void 0 : ts.factory.createObjectLiteralExpression(),
+		type: ts.factory.createTypeLiteralNode(objectBindingParams.map((p) => core.createPropertySignature({
+			name: argNames[p.name],
+			questionToken: !p.required,
+			type: getTypeFromSchema(p.schema, context)
+		})))
+	}));
+}
+function parseRequestBody(result, requestBody, context) {
+	const [schema, mode] = getSchemaFromContent(resolveReference(requestBody, context).content);
+	const type = getTypeFromSchema(schema, context);
+	const bodyVar = result.bodyVar = camelCase(type.name || getReferenceName(schema) || "body");
+	result.bodyMode = mode;
+	result.args.push(core.createParameter(bodyVar, { type }));
+}
+function createParametersNames(parameters) {
+	const argNames = {};
+	parameters.forEach(({ name }) => {
+		const stripped = camelCase(name.replace(/.+\./, ""));
+		argNames[name] = stripped in argNames ? camelCase(name) : stripped;
+	});
+	return argNames;
+}
+function splitParameters(parameters) {
+	const required = [];
+	const optional = [];
+	parameters.forEach((p) => {
+		if (p.required) required.push(p);
+		else optional.push(p);
+	});
+	return [required, optional];
+}
+function getTypeFromResponses(operationName, res, context) {
+	const codes = Object.keys(res);
+	const types = [];
+	codes.forEach((code) => {
+		const isOK = isOKResponse(code, codes.length);
+		const type = getTypeFromResponse(res[code], context);
+		if (!type) console.log(res[code]);
+		if (ts.isTypeReferenceNode(type) || core.isKeywordTypeNode(type)) {
+			if (isOK) types.push(type);
+		} else {
+			const name = getResponseName(operationName, code, context);
+			context.aliases.push(core.createTypeOrInterfaceDeclaration({
+				modifiers: [core.modifier.export],
+				name,
+				type
+			}));
+			if (isOK) types.push(ts.factory.createTypeReferenceNode(name, void 0));
+		}
+	});
+	if (types.length === 1) return types[0];
+	return ts.factory.createUnionTypeNode(types);
+}
+function isJSONResponse(responses, context) {
+	const codes = Object.keys(responses);
+	const resCode = codes.find((code) => isOKResponse(code, codes.length));
+	if (!resCode) return false;
+	const response = resolveReference(responses[resCode], context);
+	return !!response?.content?.["application/json"] || !!response?.content?.["*/*"];
+}
+function isOKResponse(code, codesCount) {
+	return codesCount === 1 || parseInt(code, 10) < 400;
+}
+function isMethod(method) {
+	return methods.includes(method);
+}
+function getTypeFromResponse(res, context) {
+	res = resolveReference(res, context);
+	if (!res?.content) return core.keywordType.void;
+	return getTypeFromSchema(getSchemaFromContent(res.content)[0], context);
+}
+function getSchemaFromContent(content) {
+	const res = Object.entries(contentTypes).find(([t]) => t in content);
+	let schema;
+	let mode;
+	if (res) {
+		const [contentType, contentMode] = res;
+		mode = contentMode;
+		schema = content?.[contentType]?.schema;
+	}
+	return [schema || { type: "string" }, mode];
+}
+function resolveReferences(array, context) {
+	return array?.map((ref) => resolveReference(ref, context)) ?? [];
+}
+function getReferenceName(obj) {
+	if (isReference(obj)) return camelCase(obj.$ref.split("/").slice(-1)[0]);
+}
+/**
+* Despite its name, OpenApi's `deepObject` serialization does not support
+* deeply nested objects. As a workaround we detect parameters that contain
+* square brackets and merge them into a single object.
+*/
+function fixDeepObjects(params) {
+	const res = [];
+	const merged = {};
+	params.forEach((p) => {
+		const m = /^(.+?)\[(.*?)\]/.exec(p.name);
+		if (!m) {
+			res.push(p);
+			return;
+		}
+		const [, name, prop] = m;
+		let obj = merged[name];
+		if (!obj) {
+			obj = merged[name] = {
+				name,
+				in: p.in,
+				style: "deepObject",
+				schema: {
+					type: "object",
+					properties: {}
+				}
+			};
+			res.push(obj);
+		}
+		obj.schema.properties[prop] = p.schema;
+	});
+	return res;
+}
+function getOperationVar(verb, path, operationId, context) {
+	const id = getOperationVarId(operationId);
+	if (id) return id;
+	return getPathVar(`${verb} ${path}`, context);
+}
+function getPathVar(path, context) {
+	path = path.replace(/\{(.+?)\}/, "by $1").replace(/\{(.+?)\}/g, "and $1");
+	let name = camelCase(path);
+	const count = context.names[name] = (context.names[name] || 0) + 1;
+	if (count > 1) name += count;
+	return name;
+}
+function getOperationVarId(id) {
+	if (!id) return;
+	if (id.match(/[^\w\s]/)) return;
+	id = camelCase(id);
+	if (core.isValidIdentifier(id)) return id;
+}
+//#endregion
+//#region src/lib/server-parser.ts
+function parseServers(servers) {
+	const props = servers.map((server, i) => [serverName(server, i), generateServerExpression(server)]);
+	return core.createObjectLiteral(props);
+}
+function defaultBaseUrl(servers) {
+	return ts.factory.createStringLiteral(defaultUrl(servers[0]));
+}
+function serverName(server, index) {
+	return server.description ? camelCase(server.description.replace(/\W+/, " ")) : `server${index + 1}`;
+}
+function generateServerExpression(server) {
+	return server.variables ? createServerFunction(server.url, server.variables) : ts.factory.createStringLiteral(server.url);
+}
+function createServerFunction(template, vars) {
+	const params = [core.createParameter(core.createObjectBinding(Object.entries(vars || {}).map(([name, value]) => {
+		return {
+			name,
+			initializer: createLiteral(value.default)
+		};
+	})), { type: ts.factory.createTypeLiteralNode(Object.entries(vars || {}).map(([name, value]) => {
+		return core.createPropertySignature({
+			name,
+			type: value.enum ? ts.factory.createUnionTypeNode(createUnion(value.enum)) : ts.factory.createUnionTypeNode([
+				core.keywordType.string,
+				core.keywordType.number,
+				core.keywordType.boolean
+			])
+		});
+	})) })];
+	return core.createArrowFunction(params, createTemplate(template));
+}
+function createUnion(strs) {
+	return strs.map((e) => ts.factory.createLiteralTypeNode(createLiteral(e)));
+}
+function createTemplate(url) {
+	const tokens = url.split(/{([\s\S]+?)}/g);
+	const spans = [];
+	const len = tokens.length;
+	for (let i = 1; i < len; i += 2) {
+		const template_factory = i === len - 2 ? ts.factory.createTemplateTail.bind(ts.factory) : ts.factory.createTemplateMiddle.bind(ts.factory);
+		spans.push(ts.factory.createTemplateSpan(ts.factory.createIdentifier(tokens[i]), template_factory(tokens[i + 1])));
+	}
+	return ts.factory.createTemplateExpression(ts.factory.createTemplateHead(tokens[0]), spans);
+}
+function createLiteral(v) {
+	switch (typeof v) {
+		case "string": return ts.factory.createStringLiteral(v);
+		case "boolean": return v ? ts.factory.createTrue() : ts.factory.createFalse();
+		case "number": return ts.factory.createNumericLiteral(String(v));
+	}
+}
+function defaultUrl(server) {
+	if (!server) return "/";
+	const { url, variables } = server;
+	if (!variables) return url;
+	return url.replace(/\{(.+?)\}/g, (m, name) => variables[name] ? String(variables[name].default) : m);
+}
+//#endregion
+//#region src/lib/core-generator.ts
+function generateServers(file, { servers }, context) {
+	servers = servers || [];
+	if (context.options.baseUrl) servers = [{ url: context.options.baseUrl }];
+	const serversConst = core.findFirstVariableStatement(file.statements, "servers");
+	const defaultsConst = core.findFirstVariableStatement(file.statements, "defaults");
+	if (!serversConst || !defaultsConst) throw new Error("Invalid template: missing servers or defaults const");
+	file = core.replaceSourceFileStatement(file, serversConst, core.updateVariableStatementValue(serversConst, "servers", parseServers(servers)));
+	file = core.replaceSourceFileStatement(file, defaultsConst, core.updateVariableStatementPropertyValue(defaultsConst, "defaults", "baseUrl", defaultBaseUrl(servers)));
+	return file;
+}
+function generateDefaults(file, context) {
+	if (context.options.importFetch) {
+		const defaultsConst = core.findFirstVariableStatement(file.statements, "defaults");
+		if (!defaultsConst) throw new Error("Invalid template: missing defaults const");
+		file = core.prependSourceFileStatements(file, core.createDefaultImportDeclaration({
+			moduleSpecifier: context.options.importFetch,
+			name: "fetch",
+			bindings: ["RequestInit", "Headers"]
+		}), core.createNamespaceImportDeclaration({
+			moduleSpecifier: "form-data",
+			name: "FormData"
+		}));
+		file = core.replaceSourceFileStatement(file, defaultsConst, core.updateVariableStatementPropertyValue(defaultsConst, "defaults", "fetch", core.toExpression("fetch")));
+	}
+	return file;
+}
+function generateFunctions(file, spec, context) {
+	const paths = Object.fromEntries(Object.entries(spec.paths ?? {}).filter(([path]) => !context.options.prefix || path.startsWith(context.options.prefix)));
+	const functions = Object.entries(paths).map(([path, pathSpec]) => {
+		const item = resolveReference(pathSpec, context);
+		return Object.entries(item).filter(([verb]) => isMethod(verb.toUpperCase())).map(([verb, entry]) => generateFunction(path, item, verb.toUpperCase(), entry, context));
+	}).flat();
+	if (context.options.typesPath && context.typesFile) {
+		context.typesFile = core.updateSourceFileStatements(context.typesFile, context.aliases);
+		file = core.updateSourceFileStatements(file, [
+			core.createNamedImportDeclaration({
+				isTypeOnly: true,
+				moduleSpecifier: context.options.typesPath,
+				bindings: context.aliases.map((a) => a.name.text)
+			}),
+			...file.statements,
+			...functions
+		]);
+	} else file = core.appendSourceFileStatements(file, ...context.aliases, ...functions);
+	return file;
+}
+function generateFunction(path, item, method, operation, context) {
+	const { name, query, header, paramsVars, args, bodyMode, bodyVar, response, responseVoid, responseJSON } = parseOperation(path, item, method, operation, context);
+	const url = generateUrl(path, generateQs(query, paramsVars));
+	const init = [ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options"))];
+	if (method !== "GET") init.push(ts.factory.createPropertyAssignment("method", ts.factory.createStringLiteral(method)));
+	if (bodyVar) init.push(core.createPropertyAssignment("body", ts.factory.createIdentifier(bodyVar)));
+	if (header.length) init.push(ts.factory.createPropertyAssignment("headers", ts.factory.createObjectLiteralExpression([ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessChain(ts.factory.createIdentifier("options"), core.questionDotToken, ts.factory.createIdentifier("headers"))), ...header.map(({ name }) => core.createPropertyAssignment(name, ts.factory.createIdentifier(paramsVars[name])))], true)));
+	const fetchArgs = [url];
+	if (init.length) {
+		const initObj = ts.factory.createObjectLiteralExpression(init, true);
+		fetchArgs.push(bodyMode ? callFunction("http", bodyMode, [initObj]) : initObj);
+	}
+	return core.addComment(core.createFunctionDeclaration(name, {
+		modifiers: [core.modifier.export, core.modifier.async],
+		type: ts.factory.createTypeReferenceNode("Promise", [ts.factory.createTypeReferenceNode("ApiResponse", [response])])
+	}, args, core.block(ts.factory.createReturnStatement(ts.factory.createAwaitExpression(callFunction("http", responseJSON ? "fetchJson" : responseVoid ? "fetchVoid" : "fetch", fetchArgs))))), operation.summary || operation.description);
+}
+function generateQs(parameters, paramsVars) {
+	if (!parameters.length) return;
+	const paramsByFormatter = groupByFormatter(parameters);
+	return callFunction("QS", "query", Object.entries(paramsByFormatter).map(([format, params]) => {
+		return callFunction("QS", format, [core.createObjectLiteral(params.map((p) => [p.name, paramsVars[p.name]]))]);
+	}));
+}
+function generateUrl(path, qs) {
+	const spans = [];
+	const head = path.replace(/(.*?)\{(.+?)\}(.*?)(?=\{|$)/g, (_, head, name, literal) => {
+		const expression = camelCase(name);
+		spans.push({
+			expression: ts.factory.createIdentifier(expression),
+			literal
+		});
+		return head;
+	});
+	if (qs) spans.push({
+		expression: qs,
+		literal: ""
+	});
+	return core.createTemplateString(head, spans);
+}
+function callFunction(ns, name, args) {
+	return core.createCall(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(ns), name), { args });
+}
+function groupByFormatter(parameters) {
+	const res = {};
+	parameters.forEach((param) => {
+		const formatter = getFormatter(param);
+		res[formatter] = res[formatter] || [];
+		res[formatter].push(param);
+	});
+	return res;
+}
+function getFormatter({ style, explode }) {
+	if (style === "spaceDelimited") return "space";
+	if (style === "pipeDelimited") return "pipe";
+	if (style === "deepObject") return "deep";
+	if (style === "form") return explode === false ? "form" : "explode";
+	return explode ? "explode" : "form";
+}
+//#endregion
+//#region src/lib/openapi-generator.ts
+async function generateClientFromFile(file, options = {}) {
+	return generateClient(await $RefParser.parse(file), {
+		cwd: path.resolve(path.dirname(file)) + "/",
+		...options
+	});
+}
+async function generateClient(spec, options = {}) {
+	if (!options.parseReference) options.parseReference = parseReference;
+	const context = await createContext(spec, options);
+	let file = await core.createSourceFileFromFile(import.meta.dirname + "/templates/_client.tpl.ts");
+	if (context.options.typesPath) context.typesFile = ts.createSourceFile("types.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+	file = generateServers(file, spec, context);
+	file = generateDefaults(file, context);
+	file = generateFunctions(file, spec, context);
+	if (context.options.typesPath) return {
+		client: file,
+		types: context.typesFile
+	};
+	return file;
+}
+//#endregion
+export { generateClientFromFile as n, generateClient as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spec2ts/openapi-client",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "Utility to convert OpenAPI v3 specifications to Typescript HTTP client using TypeScript native compiler",
   "keywords": [
     "ast",
@@ -70,9 +70,10 @@
     "prepublishOnly": "npm run test:prepublish && npm run build"
   },
   "dependencies": {
-    "@spec2ts/core": "^4.0.0",
-    "@spec2ts/jsonschema": "^4.0.0",
-    "@spec2ts/openapi": "^4.0.0",
+    "@apidevtools/json-schema-ref-parser": "^10.1.0",
+    "@spec2ts/core": "^4.0.1",
+    "@spec2ts/jsonschema": "^4.0.1",
+    "@spec2ts/openapi": "^4.0.1",
     "openapi3-ts": "^4.6.0",
     "typescript": "^6.0.0",
     "yargs": "^18.0.0"