@kubb/plugin-swr 5.0.0-alpha.8 → 5.0.0-beta.100

package/src/components/Mutation.tsx

@@ -1,276 +0,0 @@
-import { isOptional, type Operation } from '@kubb/oas'
-import { Client } from '@kubb/plugin-client/components'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams, Type } from '@kubb/react-fabric'
-import type { FabricReactNode, Params } from '@kubb/react-fabric/types'
-import type { PluginSwr } from '../types.ts'
-import { MutationKey } from './MutationKey.tsx'
-
-type Props = {
-  /**
-   * Name of the function
-   */
-  name: string
-  typeName: string
-  clientName: string
-  mutationKeyName: string
-  mutationKeyTypeName: string
-  typeSchemas: OperationSchemas
-  operation: Operation
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  /**
-   * When true, mutation parameters are passed via trigger() instead of as hook arguments
-   * @default false
-   */
-  paramsToTrigger?: boolean
-}
-
-type GetParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-  mutationKeyTypeName: string
-}
-
-// Original getParams - used when paramsToTrigger is false (default)
-function getParams({ pathParamsType, paramsCasing, dataReturnType, typeSchemas, mutationKeyTypeName }: GetParamsProps) {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-  const TExtraArg = typeSchemas.request?.name || 'never'
-
-  return FunctionParams.factory({
-    pathParams: {
-      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-      children: getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-    },
-    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,
-    options: {
-      type: `
-{
-  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${TExtraArg}> & { throwOnError?: boolean },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-}
-`,
-      default: '{}',
-    },
-  })
-}
-
-type GetTriggerParamsProps = {
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-  mutationKeyTypeName: string
-  mutationArgTypeName: string
-}
-
-// New getParams - used when paramsToTrigger is true
-function getTriggerParams({ dataReturnType, typeSchemas, mutationKeyTypeName, mutationArgTypeName }: GetTriggerParamsProps) {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-
-  return FunctionParams.factory({
-    options: {
-      type: `
-{
-  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-}
-`,
-      default: '{}',
-    },
-  })
-}
-
-type GetMutationParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  typeSchemas: OperationSchemas
-}
-
-function getMutationParams({ paramsCasing, typeSchemas }: GetMutationParamsProps) {
-  return FunctionParams.factory({
-    ...getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-    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,
-  })
-}
-
-export function Mutation({
-  name,
-  clientName,
-  mutationKeyName,
-  mutationKeyTypeName,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  dataReturnType,
-  typeSchemas,
-  operation,
-  paramsToTrigger = false,
-}: Props): FabricReactNode {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-
-  const mutationKeyParams = MutationKey.getParams({
-    pathParamsType,
-    typeSchemas,
-  })
-
-  const clientParams = Client.getParams({
-    paramsCasing,
-    paramsType,
-    typeSchemas,
-    pathParamsType,
-    isConfigurable: true,
-  })
-
-  // Use the new trigger-based approach when paramsToTrigger is true
-  if (paramsToTrigger) {
-    // Build the mutation params type (for arg destructuring)
-    const mutationParams = getMutationParams({
-      paramsCasing,
-      typeSchemas,
-    })
-
-    // Get the arg type name
-    const mutationArgTypeName = `${mutationKeyTypeName.replace('MutationKey', '')}MutationArg`
-
-    // Check if there are any mutation params (path, data, params, headers)
-    const hasMutationParams = Object.keys(mutationParams.params).length > 0
-
-    // Build the arg type for useSWRMutation
-    const argParams = FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children: Object.entries(mutationParams.params).reduce((acc, [key, value]) => {
-          if (value) {
-            acc[key] = {
-              ...value,
-              type: undefined,
-            }
-          }
-          return acc
-        }, {} as Params),
-      },
-    })
-
-    const params = getTriggerParams({
-      dataReturnType,
-      typeSchemas,
-      mutationKeyTypeName,
-      mutationArgTypeName,
-    })
-
-    const generics = [TData, TError, `${mutationKeyTypeName} | null`, mutationArgTypeName].filter(Boolean)
-
-    const mutationArg = mutationParams.toConstructor()
-
-    return (
-      <>
-        <File.Source name={mutationArgTypeName} isExportable isIndexable isTypeOnly>
-          <Type name={mutationArgTypeName} export>
-            {hasMutationParams ? `{${mutationArg}}` : 'never'}
-          </Type>
-        </File.Source>
-        <File.Source name={name} isExportable isIndexable>
-          <Function
-            name={name}
-            export
-            params={params.toConstructor()}
-            JSDoc={{
-              comments: getComments(operation),
-            }}
-          >
-            {`
-        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}(${mutationKeyParams.toCall()})
-
-        return useSWRMutation<${generics.join(', ')}>(
-          shouldFetch ? mutationKey : null,
-          async (_url${hasMutationParams ? `, { arg: ${argParams.toCall()} }` : ''}) => {
-            return ${clientName}(${clientParams.toCall()})
-          },
-          mutationOptions
-        )
-    `}
-          </Function>
-        </File.Source>
-      </>
-    )
-  }
-
-  // Original behavior (default)
-  const generics = [
-    TData,
-    TError,
-    `${mutationKeyTypeName} | null`,
-    typeSchemas.request?.name, // TExtraArg - the arg type for useSWRMutation
-  ].filter(Boolean)
-
-  const params = getParams({
-    paramsCasing,
-    pathParamsType,
-    dataReturnType,
-    typeSchemas,
-    mutationKeyTypeName,
-  })
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function
-        name={name}
-        export
-        params={params.toConstructor()}
-        JSDoc={{
-          comments: getComments(operation),
-        }}
-      >
-        {`
-        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}(${mutationKeyParams.toCall()})
-
-        return useSWRMutation<${generics.join(', ')}>(
-          shouldFetch ? mutationKey : null,
-          async (_url${typeSchemas.request?.name ? ', { arg: data }' : ''}) => {
-            return ${clientName}(${clientParams.toCall()})
-          },
-          mutationOptions
-        )
-    `}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/MutationKey.tsx

@@ -1 +0,0 @@
-export { MutationKey } from '@internals/tanstack-query'

package/src/components/Query.tsx

@@ -1,193 +0,0 @@
-import { getDefaultValue, isOptional, type Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type { PluginSwr } from '../types.ts'
-import { QueryKey } from './QueryKey.tsx'
-import { QueryOptions } from './QueryOptions.tsx'
-
-type Props = {
-  /**
-   * Name of the function
-   */
-  name: string
-  queryOptionsName: string
-  queryKeyName: string
-  queryKeyTypeName: string
-  typeSchemas: OperationSchemas
-  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
-}
-
-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'}>`
-
-  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 }'},
-  shouldFetch?: boolean,
-  immutable?: boolean
-}
-`,
-        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,
-    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: '{}',
-    },
-  })
-}
-
-export function Query({
-  name,
-  typeSchemas,
-  queryKeyName,
-  queryKeyTypeName,
-  queryOptionsName,
-  operation,
-  dataReturnType,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-}: Props): FabricReactNode {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-  const generics = [TData, TError, `${queryKeyTypeName} | null`]
-
-  const queryKeyParams = QueryKey.getParams({
-    pathParamsType,
-    typeSchemas,
-    paramsCasing,
-  })
-  const params = getParams({
-    paramsCasing,
-    paramsType,
-    pathParamsType,
-    dataReturnType,
-    typeSchemas,
-  })
-
-  const queryOptionsParams = QueryOptions.getParams({
-    paramsCasing,
-    paramsType,
-    pathParamsType,
-    typeSchemas,
-  })
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function
-        name={name}
-        export
-        params={params.toConstructor()}
-        JSDoc={{
-          comments: getComments(operation),
-        }}
-      >
-        {`
-       const { query: queryOptions, client: config = {}, shouldFetch = true, immutable } = options ?? {}
-
-       const queryKey = ${queryKeyName}(${queryKeyParams.toCall()})
-
-       return useSWR<${generics.join(', ')}>(
-        shouldFetch ? queryKey : null,
-        {
-          ...${queryOptionsName}(${queryOptionsParams.toCall()}),
-          ...(immutable ? {
-              revalidateIfStale: false,
-              revalidateOnFocus: false,
-              revalidateOnReconnect: false
-            } : { }),
-          ...queryOptions
-        }
-       )
-       `}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/QueryKey.tsx

@@ -1 +0,0 @@
-export { QueryKey } from '@internals/tanstack-query'

package/src/components/QueryOptions.tsx

@@ -1,123 +0,0 @@
-import { getDefaultValue, isOptional } from '@kubb/oas'
-import { Client } from '@kubb/plugin-client/components'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type { PluginSwr } from '../types.ts'
-
-type Props = {
-  name: string
-  clientName: string
-  typeSchemas: OperationSchemas
-  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
-}
-
-function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas }: GetParamsProps) {
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing })
-
-    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 }',
-        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): FabricReactNode {
-  const params = getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas })
-  const clientParams = Client.getParams({
-    paramsCasing,
-    paramsType,
-    typeSchemas,
-    pathParamsType,
-    isConfigurable: true,
-  })
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={params.toConstructor()}>
-        {`
-      return {
-        fetcher: async () => {
-          return ${clientName}(${clientParams.toCall()})
-        },
-      }
-      `}
-      </Function>
-    </File.Source>
-  )
-}
-
-QueryOptions.getParams = getParams

package/src/components/index.ts

@@ -1,5 +0,0 @@
-export { Mutation } from './Mutation.tsx'
-export { MutationKey } from './MutationKey.tsx'
-export { Query } from './Query.tsx'
-export { QueryKey } from './QueryKey.tsx'
-export { QueryOptions } from './QueryOptions.tsx'

package/src/generators/index.ts

@@ -1,2 +0,0 @@
-export { mutationGenerator } from './mutationGenerator.tsx'
-export { queryGenerator } from './queryGenerator.tsx'