@kubb/plugin-swr 5.0.0-alpha.9 → 5.0.0-beta.33

package/src/generators/queryGenerator.tsx

@@ -1,182 +1,170 @@
 import path from 'node:path'
-import { usePluginDriver } from '@kubb/core/hooks'
-import { pluginClientName } from '@kubb/plugin-client'
-import { Client } from '@kubb/plugin-client/components'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
+import { resolveOperationTypeNames } from '@internals/shared'
+import { resolveZodSchemaNames } from '@internals/tanstack-query'
+import { ast, defineGenerator } from '@kubb/core'
+import { Client, pluginClientName } from '@kubb/plugin-client'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/react-fabric'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { difference } from 'remeda'
 import { Query, QueryKey, QueryOptions } from '../components'
 import type { PluginSwr } from '../types'
 
-export const queryGenerator = createReactGenerator<PluginSwr>({
+export const queryGenerator = defineGenerator<PluginSwr>({
   name: 'swr-query',
-  Operation({ config, operation, generator, plugin }) {
-    const {
-      options,
-      options: { output },
-    } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
-
-    const isQuery = typeof options.query === 'boolean' ? true : options.query?.methods.some((method) => operation.method === method)
-    const isMutation = difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some(
-      (method) => operation.method === method,
-    )
-    const importPath = options.query ? options.query.importPath : '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 query = {
-      name: getName(operation, { type: 'function', prefix: 'use' }),
-      typeName: getName(operation, { type: 'type' }),
-      file: getFile(operation, { prefix: 'use' }),
-    }
+    const pluginTs = driver.getPlugin(pluginTsName)
+    if (!pluginTs) return null
+    const tsResolver = driver.getResolver(pluginTsName)
 
-    const hasClientPlugin = !!driver.getPluginByName(pluginClientName)
-    // Class-based clients are not compatible with query hooks, so we generate inline clients
-    const shouldUseClientPlugin = hasClientPlugin && options.client.clientType !== 'class'
-    const client = {
-      name: shouldUseClientPlugin
-        ? getName(operation, {
-            type: 'function',
-            pluginName: pluginClientName,
-          })
-        : getName(operation, {
-            type: 'function',
-          }),
-      file: getFile(operation, { pluginName: pluginClientName }),
-    }
+    const isQuery = query === false || (!!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase()))
+    const isMutation =
+      mutation !== false &&
+      !isQuery &&
+      difference(mutation ? mutation.methods : [], query ? query.methods : []).some((method) => node.method.toLowerCase() === method.toLowerCase())
 
-    const queryOptions = {
-      name: getName(operation, { type: 'function', suffix: 'QueryOptions' }),
-    }
-    const queryKey = {
-      name: getName(operation, { type: 'const', suffix: 'QueryKey' }),
-      typeName: getName(operation, { type: 'type', suffix: 'QueryKey' }),
-    }
+    if (!isQuery || isMutation) return null
 
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      //todo remove type?
-      schemas: getSchemas(operation, {
-        pluginName: pluginTsName,
-        type: 'type',
-      }),
-    }
+    const importPath = query ? query.importPath : 'swr'
 
-    const zod = {
-      file: getFile(operation, { pluginName: pluginZodName }),
-      schemas: getSchemas(operation, {
-        pluginName: pluginZodName,
-        type: 'function',
-      }),
-    }
+    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)
 
-    if (!isQuery || isMutation) {
-      return null
+    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 = parser === 'zod' ? 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)
+
+    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={query.file.baseName}
-        path={query.file.path}
-        meta={query.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
+        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 } })}
       >
-        {options.parser === 'zod' && (
-          <File.Import name={[zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean)} root={query.file.path} path={zod.file.path} />
-        )}
-        {options.client.importPath ? (
+        {fileZod && zodSchemaNames.length > 0 && <File.Import name={zodSchemaNames} root={meta.file.path} path={fileZod.path} />}
+        {clientOptions.importPath ? (
           <>
-            {!shouldUseClientPlugin && <File.Import name={'fetch'} path={options.client.importPath} />}
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={options.client.importPath} isTypeOnly />
-            {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
+            {!shouldUseClientPlugin && <File.Import name={'client'} path={clientOptions.importPath} />}
+            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={clientOptions.importPath} isTypeOnly />
+            {clientOptions.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={clientOptions.importPath} isTypeOnly />}
           </>
         ) : (
           <>
-            {!shouldUseClientPlugin && (
-              <File.Import name={['fetch']} root={query.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-            )}
+            {!shouldUseClientPlugin && <File.Import name={['client']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />}
             <File.Import
               name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={query.file.path}
-              path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
+              root={meta.file.path}
+              path={path.resolve(root, '.kubb/client.ts')}
               isTypeOnly
             />
-            {options.client.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={query.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} isTypeOnly />
+            {clientOptions.dataReturnType === 'full' && (
+              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
             )}
           </>
         )}
-        {shouldUseClientPlugin && <File.Import name={[client.name]} root={query.file.path} path={client.file.path} />}
-        {!shouldUseClientPlugin && (
-          <File.Import name={['buildFormData']} root={query.file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />
+        {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 />
         )}
 
-        <File.Import
-          name={[
-            type.schemas.request?.name,
-            type.schemas.response.name,
-            type.schemas.pathParams?.name,
-            type.schemas.queryParams?.name,
-            type.schemas.headerParams?.name,
-            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
-          ].filter(Boolean)}
-          root={query.file.path}
-          path={type.file.path}
-          isTypeOnly
-        />
         <QueryKey
-          name={queryKey.name}
-          typeName={queryKey.typeName}
-          operation={operation}
-          pathParamsType={options.pathParamsType}
-          typeSchemas={type.schemas}
-          paramsCasing={options.paramsCasing}
-          transformer={options.queryKey}
+          name={queryKeyName}
+          typeName={queryKeyTypeName}
+          node={node}
+          tsResolver={tsResolver}
+          pathParamsType={pathParamsType}
+          paramsCasing={paramsCasing}
+          transformer={ctx.options.queryKey}
         />
+
         {!shouldUseClientPlugin && (
           <Client
-            name={client.name}
-            baseURL={options.client.baseURL}
-            operation={operation}
-            typeSchemas={type.schemas}
-            zodSchemas={zod.schemas}
-            dataReturnType={options.client.dataReturnType || 'data'}
-            paramsCasing={options.client.paramsCasing || options.paramsCasing}
-            paramsType={options.paramsType}
-            pathParamsType={options.pathParamsType}
-            parser={options.parser}
+            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={queryOptions.name}
-          clientName={client.name}
-          typeSchemas={type.schemas}
-          paramsType={options.paramsType}
-          paramsCasing={options.paramsCasing}
-          pathParamsType={options.pathParamsType}
+          name={queryOptionsName}
+          clientName={resolvedClientName}
+          node={node}
+          tsResolver={tsResolver}
+          paramsCasing={paramsCasing}
+          paramsType={paramsType}
+          pathParamsType={pathParamsType}
         />
-        {options.query && (
+
+        {query && (
           <>
-            <File.Import name="useSWR" path={importPath} />
-            <File.Import name={['SWRResponse']} path={importPath} isTypeOnly />
+            <File.Import name={'useSWR'} path={importPath} />
+            <File.Import name={['SWRConfiguration']} path={importPath} isTypeOnly />
             <Query
-              name={query.name}
-              queryOptionsName={queryOptions.name}
-              typeSchemas={type.schemas}
-              paramsType={options.paramsType}
-              pathParamsType={options.pathParamsType}
-              operation={operation}
-              dataReturnType={options.client.dataReturnType || 'data'}
-              queryKeyName={queryKey.name}
-              paramsCasing={options.paramsCasing}
-              queryKeyTypeName={queryKey.typeName}
+              name={queryName}
+              queryOptionsName={queryOptionsName}
+              queryKeyName={queryKeyName}
+              queryKeyTypeName={queryKeyTypeName}
+              node={node}
+              tsResolver={tsResolver}
+              paramsCasing={paramsCasing}
+              paramsType={paramsType}
+              pathParamsType={pathParamsType}
+              dataReturnType={clientOptions.dataReturnType || 'data'}
             />
           </>
         )}

package/src/index.ts

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

package/src/plugin.ts

@@ -1,207 +1,154 @@
 import path from 'node:path'
-import { camelCase, pascalCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode } from '@kubb/core'
+import { camelCase } from '@internals/utils'
+import { ast, definePlugin, type Group } from '@kubb/core'
 import { 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 { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { MutationKey, QueryKey } from './components'
+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 = createPlugin<PluginSwr>((options) => {
+export const pluginSwr = definePlugin<PluginSwr>((options) => {
   const {
     output = { path: 'hooks', barrelType: 'named' },
     group,
     exclude = [],
     include,
     override = [],
-    parser = 'client',
-    transformers = {},
-    query,
-    mutation,
-    client,
+    parser = false,
     paramsType = 'inline',
     pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
-    mutationKey = MutationKey.getTransformer,
-    queryKey = QueryKey.getTransformer,
-    generators = [queryGenerator, mutationGenerator].filter(Boolean),
+    mutation = {},
+    query = {},
+    mutationKey = mutationKeyTransformer,
+    queryKey = queryKeyTransformer,
     paramsCasing,
-    contentType,
+    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)
 
-  return {
-    name: pluginSwrName,
-    options: {
-      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', 'delete', 'patch'],
-              ...mutation,
-            },
-      parser,
-      paramsType,
-      pathParamsType,
-      paramsCasing,
-      group,
-    },
-    pre: [pluginOasName, pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
-    resolvePath(baseName, pathMode, options) {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = pathMode ?? getMode(path.resolve(root, output.path))
-
-      if (mode === 'single') {
-        /**
-         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
-         */
-        return path.resolve(root, output.path)
-      }
+  const selectedGenerators =
+    options.generators ?? [queryGenerator, mutationGenerator].filter((generator): generator is NonNullable<typeof generator> => Boolean(generator))
 
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: Group['name'] = group?.name
+  const groupConfig = group
+    ? ({
+        ...group,
+        name: group.name
           ? group.name
-          : (ctx) => {
-              if (group?.type === 'path') {
+          : (ctx: { group: string }) => {
+              if (group.type === 'path') {
                 return `${ctx.group.split('/')[1]}`
               }
               return `${camelCase(ctx.group)}Controller`
-            }
-
-        return path.resolve(
-          root,
-          output.path,
-          groupName({
-            group: group.type === 'path' ? options.group.path! : options.group.tag!,
-          }),
-          baseName,
-        )
-      }
-
-      return path.resolve(root, output.path, baseName)
-    },
-    resolveName(name, type) {
-      let resolvedName = camelCase(name)
-
-      if (type === 'file' || type === 'function') {
-        resolvedName = camelCase(name, {
-          isFile: type === 'file',
-        })
-      }
-
-      if (type === 'type') {
-        resolvedName = pascalCase(name)
-      }
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
-      }
-
-      return resolvedName
-    },
-    async install() {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = getMode(path.resolve(root, output.path))
-      const oas = await this.getOas()
-      const baseURL = await this.getBaseURL()
-
-      if (baseURL) {
-        this.plugin.options.client.baseURL = baseURL
-      }
-
-      const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName)
-
-      if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) {
-        // pre add bundled fetch
-        await this.upsertFile({
-          baseName: 'fetch.ts',
-          path: path.resolve(root, '.kubb/fetch.ts'),
-          sources: [
-            {
-              name: 'fetch',
-              value: this.plugin.options.client.client === 'fetch' ? fetchClientSource : axiosClientSource,
-              isExportable: true,
-              isIndexable: true,
             },
-          ],
-          imports: [],
-          exports: [],
-        })
-      }
+      } satisfies Group)
+    : undefined
 
-      if (!hasClientPlugin) {
-        await this.addFile({
-          baseName: 'config.ts',
-          path: path.resolve(root, '.kubb/config.ts'),
-          sources: [
-            {
-              name: 'config',
-              value: configSource,
-              isExportable: false,
-              isIndexable: false,
-            },
-          ],
-          imports: [],
-          exports: [],
+  return {
+    name: pluginSwrName,
+    options,
+    dependencies: [pluginTsName, parser === 'zod' ? 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,
         })
-      }
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode,
-      })
-
-      const files = await operationGenerator.build(...generators)
-      await this.upsertFile(...files)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
+        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