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

package/src/plugin.ts

@@ -1,23 +1,42 @@
 import path from 'node:path'
-import { camelCase, pascalCase } from '@internals/utils'
-import { createFile, createSource, createText } from '@kubb/ast'
-import type { FileNode } from '@kubb/ast/types'
-import { createPlugin, getBarrelFiles, type UserGroup } 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 { version } from '../package.json'
 import { MutationKey, QueryKey } from './components'
 import { mutationGenerator, queryGenerator } from './generators'
+import { resolverSwr } from './resolvers/resolverSwr.ts'
+import { resolverSwrLegacy } from './resolvers/resolverSwrLegacy.ts'
 import type { PluginSwr } from './types.ts'
 
+/**
+ * Canonical plugin name for `@kubb/plugin-swr`, used to identify the plugin
+ * in driver lookups and warnings.
+ */
 export const pluginSwrName = 'plugin-swr' satisfies PluginSwr['name']
 
-export const pluginSwr = createPlugin<PluginSwr>((options) => {
+/**
+ * The `@kubb/plugin-swr` plugin factory.
+ *
+ * Generates SWR hooks from an OpenAPI/AST `RootNode`.
+ * Walks operations, delegates rendering to the active generators,
+ * and writes barrel files based on `output.barrelType`.
+ *
+ * @example
+ * ```ts
+ * import { pluginSwr } from '@kubb/plugin-swr'
+ *
+ * export default defineConfig({
+ *   plugins: [pluginSwr({ output: { path: 'hooks' } })],
+ * })
+ * ```
+ */
+export const pluginSwr = definePlugin<PluginSwr>((options) => {
   const {
     output = { path: 'hooks', barrelType: 'named' },
     group,
@@ -33,181 +52,127 @@ export const pluginSwr = createPlugin<PluginSwr>((options) => {
     pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
     mutationKey = MutationKey.getTransformer,
     queryKey = QueryKey.getTransformer,
-    generators = [queryGenerator, mutationGenerator].filter(Boolean),
     paramsCasing,
-    contentType,
+    resolver: userResolver,
+    transformer: userTransformer,
+    generators: userGenerators = [],
+    compatibilityPreset = 'default',
   } = options
 
+  const defaultResolver = compatibilityPreset === 'kubbV4' ? resolverSwrLegacy : resolverSwr
+
   const clientName = client?.client ?? 'axios'
   const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : undefined)
 
-  return {
-    name: pluginSwrName,
-    version,
-    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,
-      exclude,
-      include,
-      override,
-    },
-    pre: [pluginOasName, pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
-    resolvePath(baseName, pathMode, options) {
-      const root = this.root
-      const mode = pathMode ?? this.getMode(output)
-
-      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(Boolean)
 
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: UserGroup['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)
+            },
+      } satisfies Group)
+    : undefined
 
-      if (type === 'file' || type === 'function') {
-        resolvedName = camelCase(name, {
-          isFile: type === 'file',
+  return {
+    name: pluginSwrName,
+    options,
+    dependencies: [pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
+    hooks: {
+      'kubb:plugin:setup'(ctx) {
+        const resolver = userResolver ? { ...defaultResolver, ...userResolver } : defaultResolver
+
+        ctx.setOptions({
+          output,
+          transformers,
+          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: groupConfig,
+          exclude,
+          include,
+          override,
+          resolver,
         })
-      }
-
-      if (type === 'type') {
-        resolvedName = pascalCase(name)
-      }
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
-      }
-
-      return resolvedName
-    },
-    async buildStart() {
-      const root = this.root
-      const mode = this.getMode(output)
-      const oas = await this.getOas()
-      const baseURL = await this.getBaseURL()
-
-      if (baseURL) {
-        this.plugin.options.client.baseURL = baseURL
-      }
-
-      const hasClientPlugin = !!this.getPlugin(pluginClientName)
-
-      if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) {
-        // pre add bundled fetch
-        await this.upsertFile(
-          createFile({
+        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: 'fetch.ts',
             path: path.resolve(root, '.kubb/fetch.ts'),
             sources: [
-              createSource({
+              ast.createSource({
                 name: 'fetch',
-                nodes: [createText(this.plugin.options.client.client === 'fetch' ? fetchClientSource : axiosClientSource)],
+                nodes: [ast.createText(clientName === 'fetch' ? fetchClientSource : axiosClientSource)],
                 isExportable: true,
                 isIndexable: true,
               }),
             ],
-          }),
-        )
-      }
+          })
+        }
 
-      if (!hasClientPlugin) {
-        await this.addFile(
-          createFile({
+        if (!hasClientPlugin) {
+          ctx.injectFile({
             baseName: 'config.ts',
             path: path.resolve(root, '.kubb/config.ts'),
             sources: [
-              createSource({
+              ast.createSource({
                 name: 'config',
-                nodes: [createText(configSource)],
+                nodes: [ast.createText(configSource)],
                 isExportable: false,
                 isIndexable: false,
               }),
             ],
-          }),
-        )
-      }
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        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.driver.fileManager.files as unknown as FileNode[], {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
+          })
+        }
+      },
     },
   }
 })

package/src/resolvers/resolverSwr.ts

@@ -0,0 +1,26 @@
+import { camelCase } from '@internals/utils'
+import { defineResolver } from '@kubb/core'
+import type { PluginSwr } from '../types.ts'
+
+/**
+ * Resolver for `@kubb/plugin-swr` that provides the default naming
+ * and path-resolution helpers used by the plugin.
+ *
+ * @example
+ * ```ts
+ * import { resolverSwr } from '@kubb/plugin-swr'
+ *
+ * resolverSwr.default('list pets', 'function') // -> 'listPets'
+ * resolverSwr.resolveName('show pet by id')    // -> 'showPetById'
+ * ```
+ */
+export const resolverSwr = defineResolver<PluginSwr>(() => ({
+  name: 'default',
+  pluginName: 'plugin-swr',
+  default(name, type) {
+    return camelCase(name, { isFile: type === 'file' })
+  },
+  resolveName(name) {
+    return this.default(name, 'function')
+  },
+}))

package/src/resolvers/resolverSwrLegacy.ts

@@ -0,0 +1,17 @@
+import { defineResolver } from '@kubb/core'
+import type { PluginSwr } from '../types.ts'
+import { resolverSwr } from './resolverSwr.ts'
+
+/**
+ * Legacy resolver for `@kubb/plugin-swr` that reproduces the naming conventions
+ * used in Kubb v4. Enable via `compatibilityPreset: 'kubbV4'`.
+ *
+ * The naming logic is identical to the default resolver — the only difference
+ * is the `name` field (`'kubbV4'` vs `'default'`) so the driver can
+ * distinguish presets.
+ */
+export const resolverSwrLegacy = defineResolver<PluginSwr>(() => ({
+  ...resolverSwr,
+  name: 'kubbV4',
+  pluginName: 'plugin-swr',
+}))

package/src/types.ts

@@ -1,11 +1,36 @@
-import type { Transformer } from '@internals/tanstack-query'
-import type { Output, PluginFactoryOptions, ResolveNameParams, UserGroup } from '@kubb/core'
-import type { contentType, HttpMethod, Oas } from '@kubb/oas'
+import type {
+  ast,
+  CompatibilityPreset,
+  Exclude,
+  Generator,
+  Group,
+  Include,
+  Output,
+  Override,
+  PluginFactoryOptions,
+  ResolvePathOptions,
+  Resolver,
+  UserGroup,
+} from '@kubb/core'
 import type { ClientImportPath, PluginClient } from '@kubb/plugin-client'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { Generator } from '@kubb/plugin-oas/generators'
 
-export type { Transformer } from '@internals/tanstack-query'
+/**
+ * Customizes how queryKey or mutationKey arrays are built.
+ */
+export type Transformer = (props: { node: ast.OperationNode; casing: 'camelcase' | undefined }) => unknown[]
+
+/**
+ * The concrete resolver type for `@kubb/plugin-swr`.
+ * Extends the base `Resolver` with a `resolveName` helper for hook function names.
+ */
+export type ResolverSwr = Resolver & {
+  /**
+   * Resolves the hook function name for a given raw operation name.
+   * @example
+   * resolver.resolveName('show pet by id') // -> 'showPetById'
+   */
+  resolveName(this: ResolverSwr, name: string): string
+}
 
 /**
  * Customize the queryKey
@@ -22,7 +47,7 @@ type Query = {
    * Define which HttpMethods can be used for queries
    * @default ['get']
    */
-  methods?: Array<HttpMethod>
+  methods?: Array<string>
   /**
    * Path to the useQuery hook for useQuery functionality.
    * Used as `import { useQuery } from '${importPath}'`.
@@ -38,7 +63,7 @@ type Mutation = {
    * Define which HttpMethods can be used for queries
    * @default ['post', 'put', 'delete', 'patch']
    */
-  methods?: Array<HttpMethod>
+  methods?: Array<string>
   /**
    * Path to the useQuery hook for useQuery functionality.
    * Used as `import { useQuery } from '${importPath}'`.
@@ -61,12 +86,7 @@ export type Options = {
    * Specify the export location for the files and define the behavior of the output
    * @default { path: 'hooks', barrelType: 'named' }
    */
-  output?: Output<Oas>
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
-   */
-  contentType?: contentType
+  output?: Output
   /**
    * Group the SWR hooks based on the provided name.
    */
@@ -116,8 +136,23 @@ export type Options = {
     /**
      * Customize the names based on the type that is provided by the plugin.
      */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
+    name?: (name: string, type?: string) => string
   }
+  /**
+   * Apply a compatibility naming preset.
+   * @default 'default'
+   */
+  compatibilityPreset?: CompatibilityPreset
+  /**
+   * Override individual resolver methods. Any method you omit falls back to the
+   * preset resolver's implementation. Use `this.default(...)` to call it.
+   */
+  resolver?: Partial<ResolverSwr> & ThisType<ResolverSwr>
+  /**
+   * Single AST visitor applied to each node before printing.
+   * Return `null` or `undefined` from a method to leave the node unchanged.
+   */
+  transformer?: ast.Visitor
   /**
    * Define some generators next to the swr generators
    */
@@ -125,7 +160,7 @@ export type Options = {
 }
 
 type ResolvedOptions = {
-  output: Output<Oas>
+  output: Output
   client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>
   parser: Required<NonNullable<Options['parser']>>
   queryKey: QueryKey | undefined
@@ -135,13 +170,15 @@ type ResolvedOptions = {
   paramsCasing: Options['paramsCasing']
   paramsType: NonNullable<Options['paramsType']>
   pathParamsType: NonNullable<Options['pathParamsType']>
-  group: Options['group']
+  transformers: NonNullable<Options['transformers']>
+  group: Group | undefined
   exclude: NonNullable<Options['exclude']>
   include: Options['include']
   override: NonNullable<Options['override']>
+  resolver: ResolverSwr
 }
 
-export type PluginSwr = PluginFactoryOptions<'plugin-swr', Options, ResolvedOptions, never, ResolvePathOptions>
+export type PluginSwr = PluginFactoryOptions<'plugin-swr', Options, ResolvedOptions, never, ResolvePathOptions, ResolverSwr>
 
 declare global {
   namespace Kubb {