@kubb/plugin-swr 5.0.0-alpha.33 → 5.0.0-alpha.35

package/src/components/Query.tsx

@@ -1,184 +1,180 @@
-import { FunctionParams } from '@kubb/core'
-import { getDefaultValue, isOptional, type Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
+import { ast } from '@kubb/core'
+import type { PluginTs } from '@kubb/plugin-ts'
+import { functionPrinter } from '@kubb/plugin-ts'
 import { File, Function } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginSwr } from '../types.ts'
+import { buildGroupParam, getComments, resolveErrorNames, resolvePathParamType, resolveQueryGroupType } from '../utils.ts'
 import { QueryKey } from './QueryKey.tsx'
-import { QueryOptions } from './QueryOptions.tsx'
+import { getQueryOptionsParams } from './QueryOptions.tsx'
 
 type Props = {
-  /**
-   * Name of the function
-   */
   name: string
   queryOptionsName: string
   queryKeyName: string
   queryKeyTypeName: string
-  typeSchemas: OperationSchemas
+  node: ast.OperationNode
+  tsResolver: PluginTs['resolver']
   paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
   paramsType: PluginSwr['resolvedOptions']['paramsType']
   pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
   dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  operation: Operation
 }
 
-type GetParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-}
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
 
-function getParams({ paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
+function getParams(
+  node: ast.OperationNode,
+  options: {
+    paramsType: PluginSwr['resolvedOptions']['paramsType']
+    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
+    pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
+    dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
+    resolver: PluginTs['resolver']
+  },
+): ast.FunctionParametersNode {
+  const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options
 
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing })
-
-    const children = {
-      ...pathParams,
-      data: typeSchemas.request?.name
-        ? {
-            type: typeSchemas.request?.name,
-            optional: isOptional(typeSchemas.request?.schema),
-          }
-        : undefined,
-      params: typeSchemas.queryParams?.name
-        ? {
-            type: typeSchemas.queryParams?.name,
-            optional: isOptional(typeSchemas.queryParams?.schema),
-          }
-        : undefined,
-      headers: typeSchemas.headerParams?.name
-        ? {
-            type: typeSchemas.headerParams?.name,
-            optional: isOptional(typeSchemas.headerParams?.schema),
-          }
-        : undefined,
-    }
-
-    // Check if all children are optional or undefined
-    const allChildrenAreOptional = Object.values(children).every((child) => !child || child.optional)
-
-    return FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children,
-        default: allChildrenAreOptional ? '{}' : undefined,
-      },
-      options: {
-        type: `
-{
-  query?: Parameters<typeof useSWR<${[TData, TError].join(', ')}>>[2],
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
+  const responseName = resolver.resolveResponseName(node)
+  const requestName = node.requestBody?.schema ? resolver.resolveDataName(node) : undefined
+  const errorNames = resolveErrorNames(node, resolver)
+
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
+
+  const optionsParam = ast.createFunctionParameter({
+    name: 'options',
+    type: ast.createParamsType({
+      variant: 'reference',
+      name: `{
+  query?: Parameters<typeof useSWR<${TData}, ${TError}>>[2],
+  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
   shouldFetch?: boolean,
   immutable?: boolean
-}
-`,
-        default: '{}',
-      },
+}`,
+    }),
+    default: '{}',
+  })
+
+  if (paramsType === 'object') {
+    // Use createOperationParams for the grouped params (path + body + query + headers),
+    // but replace the config param with SWR's options param
+    const baseParams = ast.createOperationParams(node, {
+      paramsType: 'object',
+      pathParamsType: 'object',
+      paramsCasing,
+      resolver,
+      extraParams: [],
+    })
+
+    return ast.createFunctionParameters({
+      params: [...baseParams.params, optionsParam],
     })
   }
 
-  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,
-    data: typeSchemas.request?.name
-      ? {
-          type: typeSchemas.request?.name,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: typeSchemas.queryParams?.name,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: typeSchemas.headerParams?.name,
-          optional: isOptional(typeSchemas.headerParams?.schema),
+  // Inline params: build path + body + query (NO headers for query hooks) + options
+  const casedParams = ast.caseParams(node.parameters, paramsCasing)
+  const pathParams = casedParams.filter((p) => p.in === 'path')
+  const queryParams = casedParams.filter((p) => p.in === 'query')
+  const headerParams = casedParams.filter((p) => p.in === 'header')
+
+  const queryGroupType = resolveQueryGroupType(node, queryParams, resolver)
+
+  const bodyType = node.requestBody?.schema ? ast.createParamsType({ variant: 'reference', name: resolver.resolveDataName(node) }) : undefined
+  const bodyRequired = node.requestBody?.required ?? false
+
+  const params: Array<ast.FunctionParameterNode | ast.ParameterGroupNode> = []
+
+  // Path params
+  if (pathParams.length) {
+    const pathChildren = pathParams.map((p) =>
+      ast.createFunctionParameter({ name: p.name, type: resolvePathParamType(node, p, resolver), optional: !p.required }),
+    )
+    params.push({
+      kind: 'ParameterGroup',
+      properties: pathChildren,
+      inline: pathParamsType === 'inline',
+      default: pathChildren.every((c) => c.optional) ? '{}' : undefined,
+    })
+  }
+
+  // Body
+  if (bodyType) {
+    params.push(ast.createFunctionParameter({ name: 'data', type: bodyType, optional: !bodyRequired }))
+  }
+
+  // Query params
+  params.push(...buildGroupParam('params', node, queryParams, queryGroupType, resolver))
+
+  // Header params (included for the query hook params, consistent with old behavior)
+  const headerGroupType = node.parameters.some((p) => p.in === 'header')
+    ? (() => {
+        const hParams = casedParams.filter((p) => p.in === 'header')
+        const firstParam = hParams[0]!
+        const groupName = resolver.resolveHeaderParamsName(node, firstParam)
+        const individualName = resolver.resolveParamName(node, firstParam)
+        if (groupName !== individualName) {
+          return { type: ast.createParamsType({ variant: 'reference', name: groupName }), optional: hParams.every((p) => !p.required) }
         }
-      : undefined,
-    options: {
-      type: `
-{
-  query?: Parameters<typeof useSWR<${[TData, TError].join(', ')}>>[2],
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-  immutable?: boolean
-}
-`,
-      default: '{}',
-    },
-  })
+        return undefined
+      })()
+    : undefined
+  params.push(...buildGroupParam('headers', node, headerParams, headerGroupType, resolver))
+
+  // SWR options
+  params.push(optionsParam)
+
+  return ast.createFunctionParameters({ params })
 }
 
 export function Query({
   name,
-  typeSchemas,
+  node,
+  tsResolver,
   queryKeyName,
   queryKeyTypeName,
   queryOptionsName,
-  operation,
   dataReturnType,
   paramsType,
   paramsCasing,
   pathParamsType,
 }: Props): KubbReactNode {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
+  const responseName = tsResolver.resolveResponseName(node)
+  const errorNames = resolveErrorNames(node, tsResolver)
+
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
   const generics = [TData, TError, `${queryKeyTypeName} | null`]
 
-  const queryKeyParams = QueryKey.getParams({
-    pathParamsType,
-    typeSchemas,
-    paramsCasing,
-  })
-  const params = getParams({
-    paramsCasing,
-    paramsType,
-    pathParamsType,
-    dataReturnType,
-    typeSchemas,
-  })
+  const queryKeyParamsNode = QueryKey.getParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
+  const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
 
-  const queryOptionsParams = QueryOptions.getParams({
-    paramsCasing,
-    paramsType,
-    pathParamsType,
-    typeSchemas,
-  })
+  const paramsNode = getParams(node, { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
+
+  const queryOptionsParamsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
+  const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? ''
 
   return (
     <File.Source name={name} isExportable isIndexable>
       <Function
         name={name}
         export
-        params={params.toConstructor()}
+        params={paramsSignature}
         JSDoc={{
-          comments: getComments(operation),
+          comments: getComments(node),
         }}
       >
         {`
        const { query: queryOptions, client: config = {}, shouldFetch = true, immutable } = options ?? {}
 
-       const queryKey = ${queryKeyName}(${queryKeyParams.toCall()})
+       const queryKey = ${queryKeyName}(${queryKeyParamsCall})
 
        return useSWR<${generics.join(', ')}>(
         shouldFetch ? queryKey : null,
         {
-          ...${queryOptionsName}(${queryOptionsParams.toCall()}),
+          ...${queryOptionsName}(${queryOptionsParamsCall}),
           ...(immutable ? {
               revalidateIfStale: false,
               revalidateOnFocus: false,

package/src/components/QueryKey.tsx

@@ -1 +1,65 @@
-export { QueryKey } from '@internals/tanstack-query'
+import { URLPath } from '@internals/utils'
+import type { ast } from '@kubb/core'
+import type { PluginTs } from '@kubb/plugin-ts'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function, Type } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+import type { Transformer } from '../types.ts'
+import { buildQueryKeyParams } from '../utils.ts'
+
+type Props = {
+  name: string
+  typeName: string
+  node: ast.OperationNode
+  tsResolver: PluginTs['resolver']
+  paramsCasing: 'camelcase' | undefined
+  pathParamsType: 'object' | 'inline'
+  transformer: Transformer | undefined
+}
+
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
+
+function getParams(
+  node: ast.OperationNode,
+  options: { pathParamsType: 'object' | 'inline'; paramsCasing: 'camelcase' | undefined; resolver: PluginTs['resolver'] },
+): ast.FunctionParametersNode {
+  return buildQueryKeyParams(node, options)
+}
+
+const getTransformer: Transformer = ({ node, casing }) => {
+  const path = new URLPath(node.path, { casing })
+  const hasQueryParams = node.parameters.some((p) => p.in === 'query')
+  const hasRequestBody = !!node.requestBody?.schema
+
+  return [
+    path.toObject({ type: 'path', stringify: true }),
+    hasQueryParams ? '...(params ? [params] : [])' : undefined,
+    hasRequestBody ? '...(data ? [data] : [])' : undefined,
+  ].filter(Boolean) as string[]
+}
+
+export function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeName, transformer = getTransformer }: Props): KubbReactNode {
+  const paramsNode = getParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
+  const keys = transformer({ node, casing: paramsCasing })
+
+  return (
+    <>
+      <File.Source name={name} isExportable isIndexable>
+        <Function.Arrow name={name} export params={paramsSignature} singleLine>
+          {`[${keys.join(', ')}] as const`}
+        </Function.Arrow>
+      </File.Source>
+      <File.Source name={typeName} isExportable isIndexable isTypeOnly>
+        <Type name={typeName} export>
+          {`ReturnType<typeof ${name}>`}
+        </Type>
+      </File.Source>
+    </>
+  )
+}
+
+QueryKey.getParams = getParams
+QueryKey.getTransformer = getTransformer
+QueryKey.callPrinter = callPrinter

package/src/components/QueryOptions.tsx

@@ -1,8 +1,6 @@
-import { FunctionParams } from '@kubb/core'
-import { getDefaultValue, isOptional } from '@kubb/oas'
-import { ClientLegacy as Client } from '@kubb/plugin-client'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getPathParams } from '@kubb/plugin-oas/utils'
+import { ast } from '@kubb/core'
+import type { PluginTs } from '@kubb/plugin-ts'
+import { functionPrinter } from '@kubb/plugin-ts'
 import { File, Function } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginSwr } from '../types.ts'
@@ -10,109 +8,58 @@ import type { PluginSwr } from '../types.ts'
 type Props = {
   name: string
   clientName: string
-  typeSchemas: OperationSchemas
+  node: ast.OperationNode
+  tsResolver: PluginTs['resolver']
   paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
   paramsType: PluginSwr['resolvedOptions']['paramsType']
   pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
 }
 
-type GetParamsProps = {
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  typeSchemas: OperationSchemas
-}
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
 
-function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas }: GetParamsProps) {
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing })
+export function getQueryOptionsParams(
+  node: ast.OperationNode,
+  options: {
+    paramsType: PluginSwr['resolvedOptions']['paramsType']
+    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
+    pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
+    resolver: PluginTs['resolver']
+  },
+): ast.FunctionParametersNode {
+  const { paramsType, paramsCasing, pathParamsType, resolver } = options
+  const requestName = node.requestBody?.schema ? resolver.resolveDataName(node) : undefined
 
-    return FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children: {
-          ...pathParams,
-          data: typeSchemas.request?.name
-            ? {
-                type: typeSchemas.request?.name,
-                optional: isOptional(typeSchemas.request?.schema),
-              }
-            : undefined,
-          params: typeSchemas.queryParams?.name
-            ? {
-                type: typeSchemas.queryParams?.name,
-                optional: isOptional(typeSchemas.queryParams?.schema),
-              }
-            : undefined,
-          headers: typeSchemas.headerParams?.name
-            ? {
-                type: typeSchemas.headerParams?.name,
-                optional: isOptional(typeSchemas.headerParams?.schema),
-              }
-            : undefined,
-        },
-      },
-      config: {
-        type: typeSchemas.request?.name
-          ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }`
-          : 'Partial<RequestConfig> & { client?: Client }',
+  return ast.createOperationParams(node, {
+    paramsType,
+    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
+    paramsCasing,
+    resolver,
+    extraParams: [
+      ast.createFunctionParameter({
+        name: 'config',
+        type: ast.createParamsType({
+          variant: 'reference',
+          name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }',
+        }),
         default: '{}',
-      },
-    })
-  }
-
-  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,
-    data: typeSchemas.request?.name
-      ? {
-          type: typeSchemas.request?.name,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: typeSchemas.queryParams?.name,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: typeSchemas.headerParams?.name,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
-    config: {
-      type: typeSchemas.request?.name
-        ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }`
-        : 'Partial<RequestConfig> & { client?: Client }',
-      default: '{}',
-    },
+      }),
+    ],
   })
 }
 
-export function QueryOptions({ name, clientName, typeSchemas, paramsCasing, paramsType, pathParamsType }: Props): KubbReactNode {
-  const params = getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas })
-  const clientParams = Client.getParams({
-    paramsCasing,
-    paramsType,
-    typeSchemas,
-    pathParamsType,
-    isConfigurable: true,
-  })
+export function QueryOptions({ name, clientName, node, tsResolver, paramsCasing, paramsType, pathParamsType }: Props): KubbReactNode {
+  const paramsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
+  const paramsCall = callPrinter.print(paramsNode) ?? ''
 
   return (
     <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={params.toConstructor()}>
+      <Function name={name} export params={paramsSignature}>
         {`
       return {
         fetcher: async () => {
-          return ${clientName}(${clientParams.toCall()})
+          return ${clientName}(${paramsCall})
         },
       }
       `}
@@ -120,5 +67,3 @@ export function QueryOptions({ name, clientName, typeSchemas, paramsCasing, para
     </File.Source>
   )
 }
-
-QueryOptions.getParams = getParams