@kubb/plugin-client 5.0.0-beta.56 → 5.0.0-beta.64

package/dist/index.d.ts

@@ -234,10 +234,10 @@ type Options = OutputOptions & {
    */
   resolver?: Partial<ResolverClient> & ThisType<ResolverClient>;
   /**
-   * AST visitor applied to each operation node before code is printed.
-   * Return `null` or `undefined` to leave the node unchanged.
+   * Macros applied to each operation node before code is printed.
+   * Return `null` or `undefined` from a callback to leave the node unchanged.
    */
-  transformer?: ast.Visitor;
+  macros?: Array<ast.Macro>;
   /**
    * Custom generators that run alongside the built-in client generators.
    */

package/dist/index.js

@@ -4,7 +4,7 @@ import { source as source$1 } from "./templates/clients/fetch.source.js";
 import { source as source$2 } from "./templates/config.source.js";
 import path from "node:path";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { buildJSDoc, stringify } from "@kubb/ast/utils";
+import { buildJSDoc, caseParams, createOperationParams, stringify } from "@kubb/ast/utils";
 import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { Const, File, Function, jsxRenderer } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
@@ -359,7 +359,7 @@ function buildOperationComments(node, options = {}) {
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
 function getOperationParameters(node, options = {}) {
-	const params = ast.caseParams(node.parameters, options.paramsCasing);
+	const params = caseParams(node.parameters, options.paramsCasing);
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -492,43 +492,52 @@ const callPrinter = functionPrinter({ mode: "call" });
 function isGroup(spec) {
 	return "children" in spec;
 }
-function createType(type) {
-	return type ? ast.createParamsType({
-		variant: "reference",
-		name: type
-	}) : null;
+function groupEntries(group) {
+	return Object.entries(group.children).filter(([, child]) => child != null);
+}
+/**
+* Assembles a destructured group parameter from a binding pattern and an optional
+* type literal. Built directly because `createFunctionParameter({ properties })`
+* requires every member to carry a type, while these groups also hold untyped,
+* value-only call entries.
+*/
+function createGroupParam(elements, members, default_) {
+	return {
+		kind: "FunctionParameter",
+		name: ast.factory.createObjectBindingPattern({ elements }),
+		type: members.length ? ast.factory.createTypeLiteral({ members }) : void 0,
+		default: default_,
+		optional: false
+	};
 }
 function createDeclarationLeaf(name, spec) {
-	if (spec.default !== void 0) return ast.createFunctionParameter({
+	if (spec.default !== void 0) return ast.factory.createFunctionParameter({
 		name,
-		type: createType(spec.type) ?? void 0,
+		type: spec.type,
 		default: spec.default,
 		rest: spec.mode === "inlineSpread"
 	});
-	return ast.createFunctionParameter({
+	return ast.factory.createFunctionParameter({
 		name,
-		type: createType(spec.type) ?? void 0,
+		type: spec.type,
 		optional: !!spec.optional,
 		rest: spec.mode === "inlineSpread"
 	});
 }
 function createDeclarationParam(name, spec) {
-	if (isGroup(spec)) return ast.createParameterGroup({
-		inline: spec.mode === "inlineSpread",
-		default: spec.default,
-		properties: Object.entries(spec.children).filter(([, child]) => child != null).map(([childName, child]) => createDeclarationLeaf(childName, child))
-	});
+	if (isGroup(spec)) {
+		const entries = groupEntries(spec);
+		return createGroupParam(entries.map(([childName]) => ({ name: childName })), entries.filter(([, child]) => child.type).map(([childName, child]) => ({
+			name: childName,
+			type: child.type,
+			optional: !!child.optional || child.default !== void 0
+		})), spec.default);
+	}
 	return createDeclarationLeaf(name, spec);
 }
 function createCallParam(name, spec) {
-	if (isGroup(spec)) return ast.createParameterGroup({
-		inline: spec.mode === "inlineSpread",
-		properties: Object.entries(spec.children).filter(([, child]) => child != null).map(([childName, child]) => ast.createFunctionParameter({
-			name: child?.mode === "inlineSpread" ? spec.mode === "inlineSpread" ? child.value ?? childName : `...${child.value ?? childName}` : child?.value ? `${childName}: ${child.value}` : childName,
-			rest: spec.mode === "inlineSpread" && child?.mode === "inlineSpread"
-		}))
-	});
-	return ast.createFunctionParameter({
+	if (isGroup(spec)) return createGroupParam(groupEntries(spec).map(([childName, child]) => ({ name: child.mode === "inlineSpread" ? spec.mode === "inlineSpread" ? child.value ?? childName : `...${child.value ?? childName}` : child.value ? `${childName}: ${child.value}` : childName })), []);
+	return ast.factory.createFunctionParameter({
 		name: spec.value ?? name,
 		rest: spec.mode === "inlineSpread"
 	});
@@ -541,10 +550,10 @@ function createFunctionParams(params) {
 	const entries = Object.entries(params).filter(([, spec]) => spec != null);
 	return {
 		toConstructor() {
-			return declarationPrinter$4.print(ast.createFunctionParameters({ params: entries.map(([name, spec]) => createDeclarationParam(name, spec)) })) ?? "";
+			return declarationPrinter$4.print(ast.factory.createFunctionParameters({ params: entries.map(([name, spec]) => createDeclarationParam(name, spec)) })) ?? "";
 		},
 		toCall() {
-			return callPrinter.print(ast.createFunctionParameters({ params: entries.map(([name, spec]) => createCallParam(name, spec)) })) ?? "";
+			return callPrinter.print(ast.factory.createFunctionParameters({ params: entries.map(([name, spec]) => createCallParam(name, spec)) })) ?? "";
 		}
 	};
 }
@@ -689,12 +698,11 @@ function buildReturnStatement({ dataReturnType, parser, node, zodResolver, tsRes
 //#region src/components/Url.tsx
 const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
 function buildUrlParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
-	const urlNode = {
+	return createOperationParams({
 		...node,
 		parameters: node.parameters.filter((p) => p.in === "path"),
 		requestBody: void 0
-	};
-	return ast.createOperationParams(urlNode, {
+	}, {
 		paramsType: paramsType === "object" ? "object" : "inline",
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -739,17 +747,14 @@ function Url({ name, isExportable = true, isIndexable = true, baseURL, paramsTyp
 //#region src/components/Client.tsx
 const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 function buildClientParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable }) {
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver: tsResolver,
-		extraParams: [...isConfigurable ? [ast.createFunctionParameter({
+		extraParams: [...isConfigurable ? [ast.factory.createFunctionParameter({
 			name: "config",
-			type: ast.createParamsType({
-				variant: "reference",
-				name: buildRequestConfigType(node, tsResolver)
-			}),
+			type: buildRequestConfigType(node, tsResolver),
 			default: "{}"
 		})] : []]
 	});
@@ -1546,7 +1551,7 @@ const operationsGenerator = defineGenerator({
 				method: node.method.toLowerCase()
 			};
 		}
-		return [ast.createFile({
+		return [ast.factory.createFile({
 			baseName: file.baseName,
 			path: file.path,
 			meta: file.meta,
@@ -1566,14 +1571,14 @@ const operationsGenerator = defineGenerator({
 					baseName: file.baseName
 				}
 			}),
-			sources: [ast.createSource({
+			sources: [ast.factory.createSource({
 				name,
 				isExportable: true,
 				isIndexable: true,
-				nodes: [ast.createConst({
+				nodes: [ast.factory.createConst({
 					name,
 					export: true,
-					nodes: [ast.createText(JSON.stringify(operationsObject, void 0, 2))]
+					nodes: [ast.factory.createText(JSON.stringify(operationsObject, void 0, 2))]
 				})]
 			})]
 		})];
@@ -1998,7 +2003,7 @@ const pluginClient = definePlugin((options) => {
 	const { output = {
 		path: "clients",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], urlType = false, dataReturnType = "data", paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", operations = false, paramsCasing, clientType = options.sdk ? "class" : "function", parser = false, client = "axios", importPath, bundle = false, sdk, baseURL, resolver: userResolver, transformer: userTransformer } = options;
+	}, group, exclude = [], include, override = [], urlType = false, dataReturnType = "data", paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", operations = false, paramsCasing, clientType = options.sdk ? "class" : "function", parser = false, client = "axios", importPath, bundle = false, sdk, baseURL, resolver: userResolver, macros: userMacros } = options;
 	const resolvedImportPath = importPath ?? (!bundle ? `@kubb/plugin-client/clients/${client}` : void 0);
 	const selectedGenerators = options.generators ?? [
 		clientType === "staticClass" ? staticClassClientGenerator : clientType === "class" ? classClientGenerator : clientGenerator,
@@ -2036,7 +2041,7 @@ const pluginClient = definePlugin((options) => {
 				resolver
 			});
 			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
+			if (userMacros?.length) ctx.setMacros(userMacros);
 			for (const gen of selectedGenerators) ctx.addGenerator(gen);
 			const root = path.resolve(ctx.config.root, ctx.config.output.path);
 			if (!resolvedImportPath?.startsWith(".")) {
@@ -2044,21 +2049,21 @@ const pluginClient = definePlugin((options) => {
 				ctx.injectFile({
 					baseName: "client.ts",
 					path: path.resolve(root, ".kubb/client.ts"),
-					sources: [ast.createSource({
+					sources: [ast.factory.createSource({
 						name: "client",
-						nodes: isInlineSource ? [ast.createText(client === "fetch" ? source$1 : source)] : [],
+						nodes: isInlineSource ? [ast.factory.createText(client === "fetch" ? source$1 : source)] : [],
 						isExportable: true,
 						isIndexable: true
 					})],
-					exports: !isInlineSource && resolvedImportPath ? [ast.createExport({ path: resolvedImportPath })] : []
+					exports: !isInlineSource && resolvedImportPath ? [ast.factory.createExport({ path: resolvedImportPath })] : []
 				});
 			}
 			ctx.injectFile({
 				baseName: "config.ts",
 				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [ast.createSource({
+				sources: [ast.factory.createSource({
 					name: "config",
-					nodes: [ast.createText(source$2)],
+					nodes: [ast.factory.createText(source$2)],
 					isExportable: false,
 					isIndexable: false
 				})]