@kubb/plugin-swr 5.0.0-beta.56 → 5.0.0-beta.73

package/dist/types-Dz_j0Bqv.d.ts

@@ -1,217 +0,0 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
-import { Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
-import { ClientImportPath, PluginClient } from "@kubb/plugin-client";
-import { PluginTs, ResolverTs } from "@kubb/plugin-ts";
-import { KubbReactNode } from "@kubb/renderer-jsx/types";
-
-//#region ../../internals/tanstack-query/src/types.d.ts
-type ParamsCasing = 'camelcase' | undefined;
-type Transformer = (props: {
-  node: ast.OperationNode;
-  casing: ParamsCasing;
-}) => unknown[];
-//#endregion
-//#region ../../internals/tanstack-query/src/components/QueryKey.d.ts
-type Props = {
-  name: string;
-  typeName: string;
-  node: ast.OperationNode;
-  tsResolver: PluginTs['resolver'];
-  paramsCasing: 'camelcase' | undefined;
-  pathParamsType: 'object' | 'inline';
-  transformer: Transformer | null | undefined;
-};
-declare function QueryKey$1({
-  name,
-  node,
-  tsResolver,
-  paramsCasing,
-  pathParamsType,
-  typeName,
-  transformer
-}: Props): KubbReactNode;
-//#endregion
-//#region src/types.d.ts
-/**
- * Resolver for SWR that provides naming methods for hook functions.
- */
-type ResolverSwr = Resolver & {
-  /**
-   * Resolves the base function name for an operation.
-   *
-   * @example Resolving base operation names
-   * `resolver.resolveName('show pet by id') // -> 'showPetById'`
-   */
-  resolveName(this: ResolverSwr, name: string): string;
-  /**
-   * Resolves the output file name for a hook module.
-   */
-  resolvePathName(this: ResolverSwr, name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
-  /**
-   * Resolves a query hook function name.
-   */
-  resolveQueryName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves a mutation hook function name.
-   */
-  resolveMutationName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the query options helper name.
-   */
-  resolveQueryOptionsName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the query key helper name.
-   */
-  resolveQueryKeyName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the mutation key helper name.
-   */
-  resolveMutationKeyName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the query key type name.
-   */
-  resolveQueryKeyTypeName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the mutation key type name.
-   */
-  resolveMutationKeyTypeName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the mutation argument type name emitted alongside the mutation hook.
-   */
-  resolveMutationArgTypeName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the client function name generated inline by query hooks.
-   */
-  resolveClientName(this: ResolverSwr, node: ast.OperationNode): string;
-};
-/**
- * Customize the queryKey.
- */
-type QueryKey = Transformer;
-/**
- * Customize the mutationKey.
- */
-type MutationKey = Transformer;
-type Query = {
-  /**
-   * HTTP methods to use for queries.
-   *
-   * @default ['get']
-   */
-  methods?: Array<string>;
-  /**
-   * Path to the useSWR hook for useSWR functionality.
-   * Used as `import useSWR from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default 'swr'
-   */
-  importPath?: string;
-};
-type Mutation = {
-  /**
-   * HTTP methods to use for mutations.
-   *
-   * @default ['post', 'put', 'delete', 'patch']
-   */
-  methods?: Array<string>;
-  /**
-   * Path to the useSWRMutation hook for useSWRMutation functionality.
-   * Used as `import useSWRMutation from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default 'swr/mutation'
-   */
-  importPath?: string;
-};
-/**
- * Where the generated SWR hooks are written and how they are exported, plus the optional `group`
- * strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
- *
- * @default { path: 'hooks', barrel: { type: 'named' } }
- */
-type Options = OutputOptions & {
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>;
-  /**
-   * Tags, operations, or paths to exclude from generation.
-   */
-  exclude?: Array<Exclude>;
-  /**
-   * Tags, operations, or paths to include in generation.
-   */
-  include?: Array<Include>;
-  /**
-   * Override options for specific tags, operations, or paths.
-   */
-  override?: Array<Override<ResolvedOptions>>;
-  /**
-   * Apply casing to parameter names.
-   */
-  paramsCasing?: 'camelcase';
-  /**
-   * How parameters are passed: grouped in an object or spread inline.
-   *
-   * @default 'inline'
-   */
-  paramsType?: 'object' | 'inline';
-  /**
-   * How path parameters are passed: grouped in an object or spread inline.
-   *
-   * @default 'inline'
-   */
-  pathParamsType?: PluginClient['options']['pathParamsType'];
-  queryKey?: QueryKey;
-  /**
-   * Configure useSWR behavior.
-   */
-  query?: Partial<Query> | false;
-  mutationKey?: MutationKey;
-  /**
-   * Configure useSWRMutation behavior.
-   */
-  mutation?: Partial<Mutation> | false;
-  /**
-   * Parser to use for validating response data.
-   */
-  parser?: PluginClient['options']['parser'];
-  /**
-   * Override naming conventions for function names and types.
-   */
-  resolver?: Partial<ResolverSwr> & ThisType<ResolverSwr>;
-  /**
-   * AST visitor to transform generated nodes.
-   */
-  transformer?: ast.Visitor;
-  /**
-   * Additional generators alongside the default generators.
-   */
-  generators?: Array<Generator<PluginSwr>>;
-};
-type ResolvedOptions = {
-  output: Output;
-  group: Group | undefined;
-  exclude: NonNullable<Options['exclude']>;
-  include: Options['include'];
-  override: NonNullable<Options['override']>;
-  client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>;
-  parser: NonNullable<Options['parser']>;
-  pathParamsType: NonNullable<Options['pathParamsType']>;
-  paramsCasing: Options['paramsCasing'];
-  paramsType: NonNullable<Options['paramsType']>;
-  queryKey: QueryKey | undefined;
-  query: NonNullable<Required<Query>> | false;
-  mutationKey: MutationKey | undefined;
-  mutation: NonNullable<Required<Mutation>> | false;
-  resolver: ResolverSwr;
-};
-type PluginSwr = PluginFactoryOptions<'plugin-swr', Options, ResolvedOptions, ResolverSwr>;
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-swr': PluginSwr;
-    }
-  }
-}
-//#endregion
-export { Transformer as i, PluginSwr as n, QueryKey$1 as r, Options as t };
-//# sourceMappingURL=types-Dz_j0Bqv.d.ts.map

package/src/components/Mutation.tsx

@@ -1,155 +0,0 @@
-import { ast } from '@kubb/core'
-import type { ResolverTs } 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 { PluginSwr } from '../types.ts'
-import { buildRequestConfigType, buildStatusUnionType, getComments, resolveErrorNames } from '../utils.ts'
-
-type Props = {
-  name: string
-  clientName: string
-  mutationKeyName: string
-  mutationKeyTypeName: string
-  mutationArgTypeName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-const keysPrinter = functionPrinter({ mode: 'keys' })
-
-function createMutationArgParams(
-  node: ast.OperationNode,
-  options: {
-    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  return ast.createOperationParams(node, {
-    paramsType: 'inline',
-    pathParamsType: 'inline',
-    paramsCasing: options.paramsCasing,
-    resolver: options.resolver,
-  })
-}
-
-function buildMutationParamsNode(
-  node: ast.OperationNode,
-  options: {
-    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-    dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-    mutationKeyTypeName: string
-    mutationArgTypeName: string
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  const { dataReturnType, mutationKeyTypeName, mutationArgTypeName, resolver } = options
-  const responseName = resolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, resolver)
-
-  const TData = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, resolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  return ast.createFunctionParameters({
-    params: [
-      ast.createFunctionParameter({
-        name: 'options',
-        type: ast.createParamsType({
-          variant: 'reference',
-          name: `{
-  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
-  client?: ${buildRequestConfigType(node, resolver)},
-  shouldFetch?: boolean,
-}`,
-        }),
-        default: '{}',
-      }),
-    ],
-  })
-}
-
-export function Mutation({
-  name,
-  clientName,
-  mutationKeyName,
-  mutationKeyTypeName,
-  mutationArgTypeName,
-  paramsCasing,
-  paramsType,
-  pathParamsType,
-  dataReturnType,
-  node,
-  tsResolver,
-}: Props): KubbReactNode {
-  const responseName = tsResolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, tsResolver)
-
-  const TData = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, tsResolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const mutationArgParamsNode = createMutationArgParams(node, { paramsCasing, resolver: tsResolver })
-  const hasMutationParams = mutationArgParamsNode.params.length > 0
-  const argTypeBody = hasMutationParams ? (declarationPrinter.print(mutationArgParamsNode) ?? '') : ''
-  const argKeysStr = hasMutationParams ? (keysPrinter.print(mutationArgParamsNode) ?? '') : ''
-
-  const generics = [TData, TError, `${mutationKeyTypeName} | null`, mutationArgTypeName]
-
-  const paramsNode = buildMutationParamsNode(node, {
-    paramsCasing,
-    dataReturnType,
-    mutationKeyTypeName,
-    mutationArgTypeName,
-    resolver: tsResolver,
-  })
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  const clientCallParamsNode = ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver: tsResolver,
-    extraParams: [
-      ast.createFunctionParameter({
-        name: 'config',
-        type: ast.createParamsType({
-          variant: 'reference',
-          name: buildRequestConfigType(node, tsResolver),
-        }),
-        default: '{}',
-      }),
-    ],
-  })
-  const clientCallStr = callPrinter.print(clientCallParamsNode) ?? ''
-
-  return (
-    <>
-      <File.Source name={mutationArgTypeName} isExportable isIndexable isTypeOnly>
-        <Type name={mutationArgTypeName} export>
-          {hasMutationParams ? `{ ${argTypeBody} }` : 'never'}
-        </Type>
-      </File.Source>
-      <File.Source name={name} isExportable isIndexable>
-        <Function name={name} export params={paramsSignature} JSDoc={{ comments: getComments(node) }}>
-          {`
-        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}()
-
-        return useSWRMutation<${generics.join(', ')}>(
-          shouldFetch ? mutationKey : null,
-          async (_url${hasMutationParams ? `, { arg: { ${argKeysStr} } }` : ''}) => {
-            return ${clientName}(${clientCallStr})
-          },
-          mutationOptions
-        )
-    `}
-        </Function>
-      </File.Source>
-    </>
-  )
-}

package/src/components/MutationKey.tsx

@@ -1,25 +0,0 @@
-import type { Transformer } from '@internals/tanstack-query'
-import { MutationKey as SharedMutationKey } from '@internals/tanstack-query'
-import type { ast } from '@kubb/core'
-import { File, Type } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-
-type Props = {
-  name: string
-  typeName: string
-  node: ast.OperationNode
-  paramsCasing: 'camelcase' | undefined
-  pathParamsType: 'object' | 'inline'
-  transformer: Transformer | undefined
-}
-
-export function MutationKey({ name, typeName, node, paramsCasing, pathParamsType, transformer }: Props): KubbReactNode {
-  return (
-    <>
-      <SharedMutationKey name={name} node={node} paramsCasing={paramsCasing} pathParamsType={pathParamsType} transformer={transformer} />
-      <File.Source name={typeName} isExportable isIndexable isTypeOnly>
-        <Type export name={typeName}>{`ReturnType<typeof ${name}>`}</Type>
-      </File.Source>
-    </>
-  )
-}

package/src/components/Query.tsx

@@ -1,128 +0,0 @@
-import { ast } from '@kubb/core'
-import type { ResolverTs } 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 { getEnabledParamNames, markParamsOptional } from '@internals/tanstack-query'
-import type { PluginSwr } from '../types.ts'
-import { buildQueryKeyParams, buildStatusUnionType, getComments, resolveErrorNames } from '../utils.ts'
-import { getQueryOptionsParams } from './QueryOptions.tsx'
-
-type Props = {
-  name: string
-  queryOptionsName: string
-  queryKeyName: string
-  queryKeyTypeName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-function buildQueryParamsNode(
-  node: ast.OperationNode,
-  options: {
-    paramsType: PluginSwr['resolvedOptions']['paramsType']
-    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-    pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-    dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options
-  const responseName = resolver.resolveResponseName(node)
-  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : undefined
-  const errorNames = resolveErrorNames(node, resolver)
-
-  const TData = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, resolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const optionsParam = ast.createFunctionParameter({
-    name: 'options',
-    type: ast.createParamsType({
-      variant: 'reference',
-      name: `{
-  query?: SWRConfiguration<${[TData, TError].join(', ')}>,
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-  immutable?: boolean
-}`,
-    }),
-    default: '{}',
-  })
-
-  return ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver,
-    extraParams: [optionsParam],
-  })
-}
-
-export function Query({
-  name,
-  queryKeyTypeName,
-  queryOptionsName,
-  queryKeyName,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  dataReturnType,
-  node,
-  tsResolver,
-}: Props): KubbReactNode {
-  const responseName = tsResolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, tsResolver)
-
-  const TData = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, tsResolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-  const generics = [TData, TError, `${queryKeyTypeName} | null`]
-
-  const queryKeyParamsNode = buildQueryKeyParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
-  const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
-  const enabledNames = getEnabledParamNames(queryKeyParamsNode)
-
-  const queryOptionsParamsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
-  const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? ''
-
-  const paramsNode = markParamsOptional(
-    buildQueryParamsNode(node, { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver }),
-    enabledNames,
-  )
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  // SWR has no `enabled` option; fold the param-presence check into the null-key gate
-  // so passing `undefined` for a required param disables the request (mirrors React Query #60).
-  const shouldFetchExpr = enabledNames.length ? `shouldFetch && !!(${enabledNames.join(' && ')})` : 'shouldFetch'
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={paramsSignature} JSDoc={{ comments: getComments(node) }}>
-        {`
-       const { query: queryOptions, client: config = {}, shouldFetch = true, immutable } = options ?? {}
-
-       const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-
-       return useSWR<${generics.join(', ')}>(
-        ${shouldFetchExpr} ? queryKey : null,
-        {
-          ...${queryOptionsName}(${queryOptionsParamsCall}),
-          ...(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,56 +0,0 @@
-import type { ast } from '@kubb/core'
-import type { ResolverTs } 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 { buildQueryOptionsParams, getEnabledParamNames, injectNonNullAssertions, markParamsOptional } from '@internals/tanstack-query'
-import type { PluginSwr } from '../types.ts'
-import { buildQueryKeyParams } from '../utils.ts'
-
-type Props = {
-  name: string
-  clientName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-export function getQueryOptionsParams(
-  node: ast.OperationNode,
-  options: {
-    paramsType: PluginSwr['resolvedOptions']['paramsType']
-    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-    pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  return buildQueryOptionsParams(node, options)
-}
-
-export function QueryOptions({ name, clientName, node, tsResolver, paramsCasing, paramsType, pathParamsType }: Props): KubbReactNode {
-  const queryKeyParamsNode = buildQueryKeyParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
-  const enabledNames = getEnabledParamNames(queryKeyParamsNode)
-
-  const paramsNode = markParamsOptional(getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver }), enabledNames)
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-  const clientCallStr = injectNonNullAssertions(callPrinter.print(paramsNode) ?? '', enabledNames)
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={paramsSignature}>
-        {`
-      return {
-        fetcher: async () => {
-          return ${clientName}(${clientCallStr})
-        },
-      }
-`}
-      </Function>
-    </File.Source>
-  )
-}

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'