@kubb/plugin-client 5.0.0-alpha.9 → 5.0.0-beta.10

package/src/components/Url.tsx

@@ -1,15 +1,13 @@
+import { buildParamsMapping, getOperationParameters } from '@internals/shared'
 import { isValidVarName, URLPath } from '@internals/utils'
-import { getDefaultValue, type Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getParamsMapping, getPathParams } from '@kubb/plugin-oas/utils'
-import { Const, File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import { ast } from '@kubb/core'
+import type { ResolverTs } from '@kubb/plugin-ts'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { Const, File, Function } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginClient } from '../types.ts'
 
 type Props = {
-  /**
-   * Name of the function
-   */
   name: string
   isExportable?: boolean
   isIndexable?: boolean
@@ -18,45 +16,33 @@ type Props = {
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  typeSchemas: OperationSchemas
-  operation: Operation
+  node: ast.OperationNode
+  tsResolver: ResolverTs
 }
 
 type GetParamsProps = {
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['paramsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  typeSchemas: OperationSchemas
+  node: ast.OperationNode
+  tsResolver: ResolverTs
 }
 
-function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas }: GetParamsProps) {
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, {
-      typed: true,
-      casing: paramsCasing,
-    })
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-    return FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children: {
-          ...pathParams,
-        },
-      },
-    })
+export function buildUrlParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver }: GetParamsProps): ast.FunctionParametersNode {
+  // Build a URL-only node with only path params (no body, query, header)
+  const urlNode: ast.OperationNode = {
+    ...node,
+    parameters: node.parameters.filter((p) => p.in === 'path'),
+    requestBody: undefined,
   }
 
-  return FunctionParams.factory({
-    pathParams: typeSchemas.pathParams?.name
-      ? {
-          mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-          children: getPathParams(typeSchemas.pathParams, {
-            typed: true,
-            casing: paramsCasing,
-          }),
-          default: getDefaultValue(typeSchemas.pathParams?.schema),
-        }
-      : undefined,
+  return ast.createOperationParams(urlNode, {
+    paramsType: paramsType === 'object' ? 'object' : 'inline',
+    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
+    paramsCasing,
+    resolver: tsResolver,
   })
 }
 
@@ -64,39 +50,41 @@ export function Url({
   name,
   isExportable = true,
   isIndexable = true,
-  typeSchemas,
   baseURL,
   paramsType,
   paramsCasing,
   pathParamsType,
-  operation,
-}: Props): FabricReactNode {
-  const path = new URLPath(operation.path)
-  const params = getParams({
+  node,
+  tsResolver,
+}: Props): KubbReactNode {
+  const path = new URLPath(node.path)
+
+  const paramsNode = buildUrlParamsNode({
     paramsType,
     paramsCasing,
     pathParamsType,
-    typeSchemas,
+    node,
+    tsResolver,
   })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
-  // Generate pathParams mapping when paramsCasing is used
-  const pathParamsMapping = paramsCasing ? getParamsMapping(typeSchemas.pathParams, { casing: paramsCasing }) : undefined
+  const { path: originalPathParams } = getOperationParameters(node)
+  const { path: casedPathParams } = getOperationParameters(node, { paramsCasing })
+  const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : undefined
 
   return (
     <File.Source name={name} isExportable={isExportable} isIndexable={isIndexable}>
-      <Function name={name} export={isExportable} params={params.toConstructor()}>
+      <Function name={name} export={isExportable} params={paramsSignature}>
         {pathParamsMapping &&
           Object.entries(pathParamsMapping)
-            .filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName))
+            .filter(([originalName, camelCaseName]) => isValidVarName(originalName) && originalName !== camelCaseName)
             .map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`)
             .join('\n')}
-        {pathParamsMapping && <br />}
-        <Const name={'res'}>{`{ method: '${operation.method.toUpperCase()}', url: ${path.toTemplateString({ prefix: baseURL })} as const }`}</Const>
+        {pathParamsMapping && Object.keys(pathParamsMapping).length > 0 && <br />}
+        <Const name={'res'}>{`{ method: '${node.method.toUpperCase()}', url: ${path.toTemplateString({ prefix: baseURL })} as const }`}</Const>
         <br />
         return res
       </Function>
     </File.Source>
   )
 }
-
-Url.getParams = getParams

package/src/components/WrapperClient.tsx

@@ -1,17 +1,21 @@
-import { camelCase } from '@internals/utils'
-import { File } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import { File } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+
+type ClientController = {
+  className: string
+  propertyName: string
+}
 
 type Props = {
   name: string
-  classNames: Array<string>
+  controllers: Array<ClientController>
   isExportable?: boolean
   isIndexable?: boolean
 }
 
-export function WrapperClient({ name, classNames, isExportable = true, isIndexable = true }: Props): FabricReactNode {
-  const properties = classNames.map((className) => `  readonly ${camelCase(className)}: ${className}`).join('\n')
-  const assignments = classNames.map((className) => `    this.${camelCase(className)} = new ${className}(config)`).join('\n')
+export function WrapperClient({ name, controllers, isExportable = true, isIndexable = true }: Props): KubbReactNode {
+  const properties = controllers.map(({ className, propertyName }) => `  readonly ${propertyName}: ${className}`).join('\n')
+  const assignments = controllers.map(({ className, propertyName }) => `    this.${propertyName} = new ${className}(config)`).join('\n')
 
   const classCode = `export class ${name} {
 ${properties}

package/src/functionParams.ts

@@ -0,0 +1,118 @@
+import { ast } from '@kubb/core'
+import { functionPrinter } from '@kubb/plugin-ts'
+
+type ParamLeaf = {
+  type?: string
+  optional?: boolean
+  default?: string
+  value?: string
+  mode?: 'inlineSpread'
+}
+
+type ParamGroup = {
+  mode: 'object' | 'inlineSpread'
+  children: Record<string, ParamLeaf | undefined>
+  default?: string
+}
+
+type ParamSpec = ParamLeaf | ParamGroup
+
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
+
+function isGroup(spec: ParamSpec): spec is ParamGroup {
+  return 'children' in spec
+}
+
+function createType(type?: string) {
+  return type ? ast.createParamsType({ variant: 'reference', name: type }) : undefined
+}
+
+function createDeclarationLeaf(name: string, spec: ParamLeaf): ast.FunctionParameterNode {
+  if (spec.default !== undefined) {
+    return ast.createFunctionParameter({
+      name,
+      type: createType(spec.type),
+      default: spec.default,
+      rest: spec.mode === 'inlineSpread',
+    })
+  }
+
+  return ast.createFunctionParameter({
+    name,
+    type: createType(spec.type),
+    optional: !!spec.optional,
+    rest: spec.mode === 'inlineSpread',
+  })
+}
+
+function createDeclarationParam(name: string, spec: ParamSpec): ast.FunctionParameterNode | ast.ParameterGroupNode {
+  if (isGroup(spec)) {
+    return ast.createParameterGroup({
+      inline: spec.mode === 'inlineSpread',
+      default: spec.default,
+      properties: Object.entries(spec.children)
+        .filter(([, child]) => child !== undefined)
+        .map(([childName, child]) => createDeclarationLeaf(childName, child!)),
+    })
+  }
+
+  return createDeclarationLeaf(name, spec)
+}
+
+function createCallParam(name: string, spec: ParamSpec): ast.FunctionParameterNode | ast.ParameterGroupNode {
+  if (isGroup(spec)) {
+    return ast.createParameterGroup({
+      inline: spec.mode === 'inlineSpread',
+      properties: Object.entries(spec.children)
+        .filter(([, child]) => child !== undefined)
+        .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({
+    name: spec.value ?? name,
+    rest: spec.mode === 'inlineSpread',
+  })
+}
+
+/**
+ * Creates function parameter builders for generating function signatures and calls.
+ * Returns utilities to output constructor signatures (`toConstructor()`) or call expressions (`toCall()`).
+ */
+export function createFunctionParams(params: Record<string, ParamSpec | undefined>) {
+  const entries = Object.entries(params).filter(([, spec]) => spec !== undefined) as Array<[string, ParamSpec]>
+
+  return {
+    toConstructor() {
+      return (
+        declarationPrinter.print(
+          ast.createFunctionParameters({
+            params: entries.map(([name, spec]) => createDeclarationParam(name, spec)),
+          }),
+        ) ?? ''
+      )
+    },
+    toCall() {
+      return (
+        callPrinter.print(
+          ast.createFunctionParameters({
+            params: entries.map(([name, spec]) => createCallParam(name, spec)),
+          }),
+        ) ?? ''
+      )
+    },
+  }
+}