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

package/src/generators/mutationGenerator.tsx

@@ -1,166 +0,0 @@
-import path from 'node:path'
-import { resolveOperationTypeNames } from '@internals/shared'
-import { resolveZodSchemaNames } from '@internals/tanstack-query'
-import { ast, defineGenerator } from '@kubb/core'
-import { Client, isParserEnabled, pluginClientName } from '@kubb/plugin-client'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
-import { Mutation, MutationKey } from '../components'
-import type { PluginSwr } from '../types'
-
-/**
- * Built-in generator for `useSWRMutation` hooks. Emits one `useFooMutation` hook
- * per POST/PUT/DELETE operation (configurable via `mutation.methods`) plus
- * the matching `fooMutationKey` helper.
- */
-export const mutationGenerator = defineGenerator<PluginSwr>({
-  name: 'swr-mutation',
-  renderer: jsxRenderer,
-  operation(node, ctx) {
-    if (!ast.isHttpOperationNode(node)) return null
-    const { config, driver, resolver, root } = ctx
-    const { output, query, mutation, paramsCasing, paramsType, pathParamsType, parser, client: clientOptions, group } = ctx.options
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-    if (!pluginTs) return null
-    const tsResolver = driver.getResolver(pluginTsName)
-
-    const isQuery = query === false || (!!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase()))
-    const queryMethods = new Set(query ? query.methods : [])
-    const isMutation =
-      mutation !== false &&
-      !isQuery &&
-      (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase())
-
-    if (!isMutation) return null
-
-    const importPath = mutation ? mutation.importPath : 'swr/mutation'
-
-    const mutationHookName = resolver.resolveMutationName(node)
-    const mutationKeyName = resolver.resolveMutationKeyName(node)
-    const mutationKeyTypeName = resolver.resolveMutationKeyTypeName(node)
-    const mutationArgTypeName = resolver.resolveMutationArgTypeName(node)
-    const clientName = resolver.resolveClientName(node)
-
-    const meta = {
-      file: resolver.resolveFile({ name: mutationHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
-      fileTs: tsResolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group },
-      ),
-    }
-
-    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing, order: 'body-response-first' })
-
-    const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : undefined
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
-    const fileZod = zodResolver
-      ? zodResolver.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          { root, output: pluginZod?.options?.output ?? output, group: pluginZod?.options?.group },
-        )
-      : undefined
-    const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, parser)
-
-    const clientPlugin = driver.getPlugin(pluginClientName)
-    const hasClientPlugin = clientPlugin?.name === pluginClientName
-    const shouldUseClientPlugin = hasClientPlugin && clientOptions.clientType !== 'class'
-    const clientResolver = shouldUseClientPlugin ? driver.getResolver(pluginClientName) : undefined
-
-    const clientFile = shouldUseClientPlugin
-      ? clientResolver?.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          {
-            root,
-            output: clientPlugin?.options?.output ?? output,
-            group: clientPlugin?.options?.group,
-          },
-        )
-      : undefined
-
-    const resolvedClientName = shouldUseClientPlugin ? (clientResolver?.resolveName(node.operationId) ?? clientName) : clientName
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-      >
-        {fileZod && zodSchemaNames.length > 0 && <File.Import name={zodSchemaNames} root={meta.file.path} path={fileZod.path} />}
-        {clientOptions.importPath ? (
-          <>
-            {!shouldUseClientPlugin && <File.Import name={'client'} path={clientOptions.importPath} />}
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={clientOptions.importPath} isTypeOnly />
-          </>
-        ) : (
-          <>
-            {!shouldUseClientPlugin && <File.Import name={['client']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />}
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={meta.file.path}
-              path={path.resolve(root, '.kubb/client.ts')}
-              isTypeOnly
-            />
-          </>
-        )}
-        {shouldUseClientPlugin && clientFile && <File.Import name={[resolvedClientName]} root={meta.file.path} path={clientFile.path} />}
-        {!shouldUseClientPlugin && node.requestBody?.content?.some((e) => e.contentType === 'multipart/form-data') && (
-          <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />
-        )}
-        {!shouldUseClientPlugin && parser === 'zod' && zodResolver && node.requestBody?.content?.[0]?.schema && (
-          <File.Import name={['z']} path="zod" isTypeOnly />
-        )}
-        {meta.fileTs && importedTypeNames.length > 0 && (
-          <File.Import name={Array.from(new Set(importedTypeNames))} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
-        )}
-
-        <MutationKey
-          name={mutationKeyName}
-          typeName={mutationKeyTypeName}
-          node={node}
-          pathParamsType={pathParamsType}
-          paramsCasing={paramsCasing}
-          transformer={ctx.options.mutationKey}
-        />
-
-        {!shouldUseClientPlugin && (
-          <Client
-            name={resolvedClientName}
-            baseURL={clientOptions.baseURL}
-            dataReturnType={clientOptions.dataReturnType || 'data'}
-            paramsCasing={clientOptions.paramsCasing || paramsCasing}
-            paramsType={paramsType}
-            pathParamsType={pathParamsType}
-            parser={parser}
-            node={node}
-            tsResolver={tsResolver}
-            zodResolver={zodResolver}
-          />
-        )}
-
-        {mutation && (
-          <>
-            <File.Import name={'useSWRMutation'} path={importPath} />
-            <File.Import name={['SWRMutationConfiguration']} path={importPath} isTypeOnly />
-            <Mutation
-              name={mutationHookName}
-              clientName={resolvedClientName}
-              mutationKeyName={mutationKeyName}
-              mutationKeyTypeName={mutationKeyTypeName}
-              mutationArgTypeName={mutationArgTypeName}
-              node={node}
-              tsResolver={tsResolver}
-              dataReturnType={clientOptions.dataReturnType || 'data'}
-              paramsCasing={paramsCasing}
-              paramsType={paramsType}
-              pathParamsType={pathParamsType}
-            />
-          </>
-        )}
-      </File>
-    )
-  },
-})

package/src/generators/queryGenerator.tsx

@@ -1,170 +0,0 @@
-import path from 'node:path'
-import { resolveOperationTypeNames } from '@internals/shared'
-import { resolveZodSchemaNames } from '@internals/tanstack-query'
-import { ast, defineGenerator } from '@kubb/core'
-import { Client, isParserEnabled, pluginClientName } from '@kubb/plugin-client'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
-import { Query, QueryKey, QueryOptions } from '../components'
-import type { PluginSwr } from '../types'
-
-export const queryGenerator = defineGenerator<PluginSwr>({
-  name: 'swr-query',
-  renderer: jsxRenderer,
-  operation(node, ctx) {
-    if (!ast.isHttpOperationNode(node)) return null
-    const { config, driver, resolver, root } = ctx
-    const { output, query, mutation, paramsCasing, paramsType, pathParamsType, parser, client: clientOptions, group } = ctx.options
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-    if (!pluginTs) return null
-    const tsResolver = driver.getResolver(pluginTsName)
-
-    const isQuery = query === false || (!!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase()))
-    const queryMethods = new Set(query ? query.methods : [])
-    const isMutation =
-      mutation !== false &&
-      !isQuery &&
-      (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase())
-
-    if (!isQuery || isMutation) return null
-
-    const importPath = query ? query.importPath : 'swr'
-
-    const queryName = resolver.resolveQueryName(node)
-    const queryOptionsName = resolver.resolveQueryOptionsName(node)
-    const queryKeyName = resolver.resolveQueryKeyName(node)
-    const queryKeyTypeName = resolver.resolveQueryKeyTypeName(node)
-    const clientName = resolver.resolveClientName(node)
-
-    const meta = {
-      file: resolver.resolveFile({ name: queryName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
-      fileTs: tsResolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group },
-      ),
-    }
-
-    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, {
-      paramsCasing,
-      exclude: [queryKeyTypeName],
-      order: 'body-response-first',
-    })
-
-    const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : undefined
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
-    const fileZod = zodResolver
-      ? zodResolver.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          { root, output: pluginZod?.options?.output ?? output, group: pluginZod?.options?.group },
-        )
-      : undefined
-    const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, parser)
-
-    const clientPlugin = driver.getPlugin(pluginClientName)
-    const hasClientPlugin = clientPlugin?.name === pluginClientName
-    const shouldUseClientPlugin = hasClientPlugin && clientOptions.clientType !== 'class'
-    const clientResolver = shouldUseClientPlugin ? driver.getResolver(pluginClientName) : undefined
-
-    const clientFile = shouldUseClientPlugin
-      ? clientResolver?.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          {
-            root,
-            output: clientPlugin?.options?.output ?? output,
-            group: clientPlugin?.options?.group,
-          },
-        )
-      : undefined
-
-    const resolvedClientName = shouldUseClientPlugin ? (clientResolver?.resolveName(node.operationId) ?? clientName) : clientName
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-      >
-        {fileZod && zodSchemaNames.length > 0 && <File.Import name={zodSchemaNames} root={meta.file.path} path={fileZod.path} />}
-        {clientOptions.importPath ? (
-          <>
-            {!shouldUseClientPlugin && <File.Import name={'client'} path={clientOptions.importPath} />}
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={clientOptions.importPath} isTypeOnly />
-          </>
-        ) : (
-          <>
-            {!shouldUseClientPlugin && <File.Import name={['client']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />}
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={meta.file.path}
-              path={path.resolve(root, '.kubb/client.ts')}
-              isTypeOnly
-            />
-          </>
-        )}
-        {shouldUseClientPlugin && clientFile && <File.Import name={[resolvedClientName]} root={meta.file.path} path={clientFile.path} />}
-        {!shouldUseClientPlugin && <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />}
-        {meta.fileTs && importedTypeNames.length > 0 && (
-          <File.Import name={Array.from(new Set(importedTypeNames))} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
-        )}
-
-        <QueryKey
-          name={queryKeyName}
-          typeName={queryKeyTypeName}
-          node={node}
-          tsResolver={tsResolver}
-          pathParamsType={pathParamsType}
-          paramsCasing={paramsCasing}
-          transformer={ctx.options.queryKey}
-        />
-
-        {!shouldUseClientPlugin && (
-          <Client
-            name={resolvedClientName}
-            baseURL={clientOptions.baseURL}
-            dataReturnType={clientOptions.dataReturnType || 'data'}
-            paramsCasing={clientOptions.paramsCasing || paramsCasing}
-            paramsType={paramsType}
-            pathParamsType={pathParamsType}
-            parser={parser}
-            node={node}
-            tsResolver={tsResolver}
-            zodResolver={zodResolver}
-          />
-        )}
-
-        <QueryOptions
-          name={queryOptionsName}
-          clientName={resolvedClientName}
-          node={node}
-          tsResolver={tsResolver}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          pathParamsType={pathParamsType}
-        />
-
-        {query && (
-          <>
-            <File.Import name={'useSWR'} path={importPath} />
-            <File.Import name={['SWRConfiguration']} path={importPath} isTypeOnly />
-            <Query
-              name={queryName}
-              queryOptionsName={queryOptionsName}
-              queryKeyName={queryKeyName}
-              queryKeyTypeName={queryKeyTypeName}
-              node={node}
-              tsResolver={tsResolver}
-              paramsCasing={paramsCasing}
-              paramsType={paramsType}
-              pathParamsType={pathParamsType}
-              dataReturnType={clientOptions.dataReturnType || 'data'}
-            />
-          </>
-        )}
-      </File>
-    )
-  },
-})

package/src/index.ts

@@ -1,2 +0,0 @@
-export { default, pluginSwr, pluginSwrName } from './plugin.ts'
-export type { PluginSwr, Transformer } from './types.ts'

package/src/plugin.ts

@@ -1,142 +0,0 @@
-import path from 'node:path'
-import { createGroupConfig } from '@internals/shared'
-import { ast, definePlugin } from '@kubb/core'
-import { isParserEnabled, pluginClientName } from '@kubb/plugin-client'
-import { source as axiosClientSource } from '@kubb/plugin-client/templates/clients/axios.source'
-import { source as fetchClientSource } from '@kubb/plugin-client/templates/clients/fetch.source'
-import { source as configSource } from '@kubb/plugin-client/templates/config.source'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { mutationKeyTransformer, queryKeyTransformer } from '@internals/tanstack-query'
-import { mutationGenerator, queryGenerator } from './generators'
-import { resolverSwr } from './resolvers/resolverSwr.ts'
-import type { PluginSwr } from './types.ts'
-
-export const pluginSwrName = 'plugin-swr' satisfies PluginSwr['name']
-
-export const pluginSwr = definePlugin<PluginSwr>((options) => {
-  const {
-    output = { path: 'hooks', barrel: { type: 'named' } },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    parser = false,
-    paramsType = 'inline',
-    pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
-    mutation = {},
-    query = {},
-    mutationKey = mutationKeyTransformer,
-    queryKey = queryKeyTransformer,
-    paramsCasing,
-    client,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators = [],
-  } = options
-
-  const clientName = client?.client ?? 'axios'
-  const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : undefined)
-
-  const selectedGenerators =
-    options.generators ?? [queryGenerator, mutationGenerator].filter((generator): generator is NonNullable<typeof generator> => Boolean(generator))
-
-  const groupConfig = createGroupConfig(group) ?? undefined
-
-  return {
-    name: pluginSwrName,
-    options,
-    dependencies: [pluginTsName, isParserEnabled(parser) ? pluginZodName : undefined].filter((dependency): dependency is string => Boolean(dependency)),
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        const resolver = userResolver ? { ...resolverSwr, ...userResolver } : resolverSwr
-
-        ctx.setOptions({
-          output,
-          client: {
-            bundle: client?.bundle,
-            baseURL: client?.baseURL,
-            client: clientName,
-            clientType: client?.clientType ?? 'function',
-            importPath: clientImportPath,
-            dataReturnType: client?.dataReturnType ?? 'data',
-            paramsCasing,
-          },
-          queryKey,
-          query:
-            query === false
-              ? false
-              : {
-                  importPath: 'swr',
-                  methods: ['get'],
-                  ...query,
-                },
-          mutationKey,
-          mutation:
-            mutation === false
-              ? false
-              : {
-                  importPath: 'swr/mutation',
-                  methods: ['post', 'put', 'patch', 'delete'],
-                  ...mutation,
-                },
-          parser,
-          paramsType,
-          pathParamsType,
-          paramsCasing,
-          group: groupConfig,
-          exclude,
-          include,
-          override,
-          resolver,
-        })
-        ctx.setResolver(resolver)
-        if (userTransformer) {
-          ctx.setTransformer(userTransformer)
-        }
-
-        for (const gen of selectedGenerators) {
-          ctx.addGenerator(gen)
-        }
-        for (const gen of userGenerators) {
-          ctx.addGenerator(gen)
-        }
-
-        const root = path.resolve(ctx.config.root, ctx.config.output.path)
-        const hasClientPlugin = !!ctx.config.plugins?.some((p) => (p as { name?: string }).name === pluginClientName)
-
-        if (client?.bundle && !hasClientPlugin && !clientImportPath) {
-          ctx.injectFile({
-            baseName: 'client.ts',
-            path: path.resolve(root, '.kubb/client.ts'),
-            sources: [
-              ast.createSource({
-                name: 'client',
-                nodes: [ast.createText(clientName === 'fetch' ? fetchClientSource : axiosClientSource)],
-                isExportable: true,
-                isIndexable: true,
-              }),
-            ],
-          })
-        }
-
-        if (!hasClientPlugin) {
-          ctx.injectFile({
-            baseName: 'config.ts',
-            path: path.resolve(root, '.kubb/config.ts'),
-            sources: [
-              ast.createSource({
-                name: 'config',
-                nodes: [ast.createText(configSource)],
-                isExportable: false,
-                isIndexable: false,
-              }),
-            ],
-          })
-        }
-      },
-    },
-  }
-})
-
-export default pluginSwr

package/src/resolvers/resolverSwr.ts

@@ -1,56 +0,0 @@
-import { camelCase, toFilePath } from '@internals/utils'
-import { defineResolver } from '@kubb/core'
-import type { PluginSwr } from '../types.ts'
-
-function capitalize(name: string): string {
-  return `${name.charAt(0).toUpperCase()}${name.slice(1)}`
-}
-
-/**
- * Naming convention resolver for the SWR plugin.
- *
- * Provides default naming helpers using camelCase for functions and file paths.
- *
- * @example
- * `resolverSwr.default('list pets', 'function')  // → 'listPets'`
- */
-export const resolverSwr = defineResolver<PluginSwr>(() => ({
-  name: 'default',
-  pluginName: 'plugin-swr',
-  default(name, type) {
-    return type === 'file' ? toFilePath(name) : camelCase(name)
-  },
-  resolveName(name) {
-    return this.default(name, 'function')
-  },
-  resolvePathName(name, type) {
-    return this.default(name, type)
-  },
-  resolveQueryName(node) {
-    return `use${capitalize(this.resolveName(node.operationId))}`
-  },
-  resolveMutationName(node) {
-    return `use${capitalize(this.resolveName(node.operationId))}`
-  },
-  resolveQueryOptionsName(node) {
-    return `${this.resolveName(node.operationId)}QueryOptions`
-  },
-  resolveQueryKeyName(node) {
-    return `${this.resolveName(node.operationId)}QueryKey`
-  },
-  resolveMutationKeyName(node) {
-    return `${this.resolveName(node.operationId)}MutationKey`
-  },
-  resolveQueryKeyTypeName(node) {
-    return `${capitalize(this.resolveName(node.operationId))}QueryKey`
-  },
-  resolveMutationKeyTypeName(node) {
-    return `${capitalize(this.resolveName(node.operationId))}MutationKey`
-  },
-  resolveMutationArgTypeName(node) {
-    return `${capitalize(this.resolveName(node.operationId))}MutationArg`
-  },
-  resolveClientName(node) {
-    return this.resolveName(node.operationId)
-  },
-}))