@kubb/plugin-swr 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/generators/mutationGenerator.tsx

@@ -0,0 +1,109 @@
+import transformers from '@kubb/core/transformers'
+import { pluginClientName } from '@kubb/plugin-client'
+import { Client } from '@kubb/plugin-client/components'
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOperationManager } from '@kubb/plugin-oas/hooks'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { pluginZodName } from '@kubb/plugin-zod'
+import { File, useApp } from '@kubb/react'
+import { MutationKey } from '../components'
+import { Mutation } from '../components'
+import type { PluginSwr } from '../types'
+
+export const mutationGenerator = createReactGenerator<PluginSwr>({
+  name: 'swr-mutation',
+  Operation({ options, operation }) {
+    const {
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginSwr>()
+    const { getSchemas, getName, getFile } = useOperationManager()
+
+    const isMutate = typeof options.query === 'boolean' ? options.mutation : !!options.mutation.methods?.some((method) => operation.method === method)
+
+    const mutation = {
+      name: getName(operation, { type: 'function', prefix: 'use' }),
+      typeName: getName(operation, { type: 'type' }),
+      file: getFile(operation, { prefix: 'use' }),
+    }
+
+    const type = {
+      file: getFile(operation, { pluginKey: [pluginTsName] }),
+      //todo remove type?
+      schemas: getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' }),
+    }
+
+    const zod = {
+      file: getFile(operation, { pluginKey: [pluginZodName] }),
+      schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
+    }
+
+    const client = {
+      name: getName(operation, { type: 'function', pluginKey: [pluginClientName] }),
+    }
+
+    const mutationKey = {
+      name: getName(operation, { type: 'const', suffix: 'MutationKey' }),
+      typeName: getName(operation, { type: 'type', suffix: 'MutationKey' }),
+    }
+
+    if (!isMutate) {
+      return null
+    }
+
+    return (
+      <File baseName={mutation.file.baseName} path={mutation.file.path} meta={mutation.file.meta} banner={output?.banner} footer={output?.footer}>
+        {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={mutation.file.path} path={zod.file.path} />}
+        <File.Import name="useSWRMutation" path={options.mutation.importPath} />
+        <File.Import name={['SWRMutationResponse']} path={options.mutation.importPath} isTypeOnly />
+        <File.Import name={'client'} path={options.client.importPath} />
+        <File.Import name={['RequestConfig', 'ResponseConfig']} path={options.client.importPath} 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={mutation.file.path}
+          path={type.file.path}
+          isTypeOnly
+        />
+        <MutationKey
+          name={mutationKey.name}
+          typeName={mutationKey.typeName}
+          operation={operation}
+          pathParamsType={options.pathParamsType}
+          typeSchemas={type.schemas}
+          keysFn={options.mutation.key}
+        />
+        <Client
+          name={client.name}
+          isExportable={false}
+          isIndexable={false}
+          baseURL={options.baseURL}
+          operation={operation}
+          typeSchemas={type.schemas}
+          zodSchemas={zod.schemas}
+          dataReturnType={options.client.dataReturnType}
+          pathParamsType={options.pathParamsType}
+          parser={options.parser}
+        />
+        <Mutation
+          name={mutation.name}
+          clientName={client.name}
+          typeName={mutation.typeName}
+          typeSchemas={type.schemas}
+          operation={operation}
+          dataReturnType={options.client.dataReturnType}
+          pathParamsType={options.pathParamsType}
+          mutationKeyName={mutationKey.name}
+          mutationKeyTypeName={mutationKey.typeName}
+        />
+      </File>
+    )
+  },
+})

package/src/generators/queryGenerator.tsx

@@ -0,0 +1,114 @@
+import transformers from '@kubb/core/transformers'
+import { pluginClientName } from '@kubb/plugin-client'
+import { Client } from '@kubb/plugin-client/components'
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOperationManager } from '@kubb/plugin-oas/hooks'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { pluginZodName } from '@kubb/plugin-zod'
+import { File, useApp } from '@kubb/react'
+import { Query, QueryOptions } from '../components'
+import { QueryKey } from '../components'
+import type { PluginSwr } from '../types'
+
+export const queryGenerator = createReactGenerator<PluginSwr>({
+  name: 'swr-query',
+  Operation({ options, operation }) {
+    const {
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginSwr>()
+    const { getSchemas, getName, getFile } = useOperationManager()
+
+    const isQuery = typeof options.query === 'boolean' ? options.query : !!options.query.methods?.some((method) => operation.method === method)
+
+    const query = {
+      name: getName(operation, { type: 'function', prefix: 'use' }),
+      typeName: getName(operation, { type: 'type' }),
+      file: getFile(operation, { prefix: 'use' }),
+    }
+
+    const client = {
+      name: getName(operation, { type: 'function', pluginKey: [pluginClientName] }),
+    }
+
+    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' }),
+    }
+
+    const type = {
+      file: getFile(operation, { pluginKey: [pluginTsName] }),
+      //todo remove type?
+      schemas: getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' }),
+    }
+
+    const zod = {
+      file: getFile(operation, { pluginKey: [pluginZodName] }),
+      schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
+    }
+
+    if (!isQuery) {
+      return null
+    }
+
+    return (
+      <File baseName={query.file.baseName} path={query.file.path} meta={query.file.meta} banner={output?.banner} footer={output?.footer}>
+        {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={query.file.path} path={zod.file.path} />}
+        <File.Import name="useSWR" path={options.query.importPath} />
+        <File.Import name={['SWRResponse']} path={options.query.importPath} isTypeOnly />
+        <File.Import name={'client'} path={options.client.importPath} />
+        <File.Import name={['RequestConfig']} path={options.client.importPath} isTypeOnly />
+        {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} 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}
+          keysFn={options.query.key}
+        />
+        <Client
+          name={client.name}
+          isExportable={false}
+          isIndexable={false}
+          baseURL={options.baseURL}
+          operation={operation}
+          typeSchemas={type.schemas}
+          zodSchemas={zod.schemas}
+          dataReturnType={options.client.dataReturnType}
+          pathParamsType={options.pathParamsType}
+          parser={options.parser}
+        />
+        <QueryOptions name={queryOptions.name} clientName={client.name} typeSchemas={type.schemas} pathParamsType={options.pathParamsType} />
+        <Query
+          name={query.name}
+          queryOptionsName={queryOptions.name}
+          typeSchemas={type.schemas}
+          pathParamsType={options.pathParamsType}
+          operation={operation}
+          dataReturnType={options.client.dataReturnType}
+          queryKeyName={queryKey.name}
+          queryKeyTypeName={queryKey.typeName}
+        />
+      </File>
+    )
+  },
+})

package/src/plugin.ts

@@ -1,52 +1,72 @@
 import path from 'node:path'
 
-import { FileManager, PluginManager, createPlugin } from '@kubb/core'
+import { FileManager, type Group, PluginManager, createPlugin } from '@kubb/core'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
 import { renderTemplate } from '@kubb/core/utils'
-import { pluginOasName } from '@kubb/plugin-oas'
+import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
 
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
 
-import { OperationGenerator } from './OperationGenerator.tsx'
-import { Mutation, Query, QueryOptions } from './components/index.ts'
-
 import type { Plugin } from '@kubb/core'
 import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
+import { mutationGenerator, queryGenerator } from './generators'
 import type { PluginSwr } from './types.ts'
 
 export const pluginSwrName = 'plugin-swr' satisfies PluginSwr['name']
 
 export const pluginSwr = createPlugin<PluginSwr>((options) => {
-  const { output = { path: 'hooks' }, group, exclude = [], include, override = [], parser, transformers = {}, templates, dataReturnType = 'data' } = options
-  const template = group?.output ? group.output : `${output.path}/{{tag}}SWRController`
+  const {
+    output = { path: 'hooks', barrelType: 'named' },
+    group,
+    exclude = [],
+    include,
+    override = [],
+    parser = 'client',
+    transformers = {},
+    query,
+    mutation,
+    client,
+    pathParamsType = 'inline',
+    generators = [queryGenerator, mutationGenerator].filter(Boolean),
+  } = options
 
   return {
     name: pluginSwrName,
-    output: {
-      exportType: 'barrelNamed',
-      ...output,
-    },
     options: {
-      extName: output.extName,
-      templates: {
-        mutation: Mutation.templates,
-        query: Query.templates,
-        queryOptions: QueryOptions.templates,
-        ...templates,
-      },
+      output,
+      pathParamsType,
       client: {
         importPath: '@kubb/plugin-client/client',
-        ...options.client,
+        dataReturnType: 'data',
+        ...client,
+      },
+      query: {
+        key: (key: unknown[]) => key,
+        importPath: 'swr',
+        methods: ['get'],
+        ...query,
+      },
+      mutation: {
+        key: (key: unknown[]) => key,
+        importPath: 'swr/mutation',
+        methods: ['post', 'put', 'delete', 'patch'],
+        ...mutation,
       },
-      dataReturnType,
       parser,
+      baseURL: undefined,
     },
     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 ?? FileManager.getMode(path.resolve(root, output.path))
 
+      if (options?.tag && group?.type === 'tag') {
+        const groupName: Group['name'] = group?.name ? group.name : (ctx) => `${ctx.group}Controller`
+
+        return path.resolve(root, output.path, groupName({ group: camelCase(options.tag) }), baseName)
+      }
+
       if (mode === 'single') {
         /**
          * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
@@ -55,12 +75,6 @@ export const pluginSwr = createPlugin<PluginSwr>((options) => {
         return path.resolve(root, output.path)
       }
 
-      if (options?.tag && group?.type === 'tag') {
-        const tag = camelCase(options.tag)
-
-        return path.resolve(root, renderTemplate(template, { tag }), baseName)
-      }
-
       return path.resolve(root, output.path, baseName)
     },
     resolveName(name, type) {
@@ -68,7 +82,6 @@ export const pluginSwr = createPlugin<PluginSwr>((options) => {
 
       if (type === 'file' || type === 'function') {
         resolvedName = camelCase(name, {
-          prefix: 'use',
           isFile: type === 'file',
         })
       }
@@ -89,34 +102,40 @@ export const pluginSwr = createPlugin<PluginSwr>((options) => {
       const oas = await swaggerPlugin.context.getOas()
       const root = path.resolve(this.config.root, this.config.output.path)
       const mode = FileManager.getMode(path.resolve(root, output.path))
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        oas,
-        pluginManager: this.pluginManager,
-        plugin: this.plugin,
-        contentType: swaggerPlugin.context.contentType,
-        exclude,
-        include,
-        override,
-        mode,
-      })
-
-      const files = await operationGenerator.build()
+      const baseURL = await swaggerPlugin.context.getBaseURL()
+
+      const operationGenerator = new OperationGenerator(
+        {
+          ...this.plugin.options,
+          baseURL,
+        },
+        {
+          oas,
+          pluginManager: this.pluginManager,
+          plugin: this.plugin,
+          contentType: swaggerPlugin.context.contentType,
+          exclude,
+          include,
+          override,
+          mode,
+        },
+      )
+
+      const files = await operationGenerator.build(...generators)
       await this.addFile(...files)
 
-      if (this.config.output.exportType) {
-        const barrelFiles = await this.fileManager.getBarrelFiles({
-          root,
-          output,
-          files: this.fileManager.files,
-          meta: {
-            pluginKey: this.plugin.key,
-          },
-          logger: this.logger,
-        })
+      const barrelFiles = await this.fileManager.getBarrelFiles({
+        type: output.barrelType ?? 'named',
+        root,
+        output,
+        files: this.fileManager.files,
+        meta: {
+          pluginKey: this.plugin.key,
+        },
+        logger: this.logger,
+      })
 
-        await this.addFile(...barrelFiles)
-      }
+      await this.addFile(...barrelFiles)
     },
   }
 })

package/src/types.ts

@@ -1,59 +1,17 @@
-import type { Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type * as KubbFile from '@kubb/fs/types'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { Mutation } from './components/Mutation.tsx'
-import type { Query } from './components/Query.tsx'
-import type { QueryOptions } from './components/QueryOptions.tsx'
-
-type Templates = {
-  mutation?: typeof Mutation.templates | false
-  query?: typeof Query.templates | false
-  queryOptions?: typeof QueryOptions.templates | false
-}
+import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { HttpMethod } from '@kubb/oas'
+import type { PluginClient } from '@kubb/plugin-client'
+import type { Exclude, Generator, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
 
 export type Options = {
-  output?: {
-    /**
-     * Output to save the SWR hooks.
-     * @default `"hooks"`
-     */
-    path: string
-    /**
-     * Name to be used for the `export * as {{exportAs}} from './'`
-     */
-    exportAs?: string
-    /**
-     * Add an extension to the generated imports and exports, default it will not use an extension
-     */
-    extName?: KubbFile.Extname
-    /**
-     * Define what needs to exported, here you can also disable the export of barrel files
-     * @default `'barrel'`
-     */
-    exportType?: 'barrel' | 'barrelNamed' | false
-  }
+  /**
+   * @default 'hooks'
+   */
+  output?: Output
   /**
    * Group the SWR hooks based on the provided name.
    */
-  group?: {
-    /**
-     * Tag will group based on the operation tag inside the Swagger file
-     */
-    type: 'tag'
-    /**
-     * Relative path to save the grouped SWR hooks.
-     *
-     * `{{tag}}` will be replaced by the current tagName.
-     * @example `${output}/{{tag}}Controller` => `hooks/PetController`
-     * @default `${output}/{{tag}}Controller`
-     */
-    output?: string
-    /**
-     * Name to be used for the `export * as {{exportAs}} from './`
-     * @default `"{{tag}}SWRHooks"`
-     */
-    exportAs?: string
-  }
+  group?: Group
   /**
    * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
    */
@@ -66,26 +24,60 @@ export type Options = {
    * Array containing override parameters to override `options` based on tags/operations/methods/paths.
    */
   override?: Array<Override<ResolvedOptions>>
-  client?: {
+  client?: Pick<PluginClient['options'], 'dataReturnType' | 'importPath'>
+  query?: {
     /**
-     * Path to the client import path that will be used to do the API calls.
-     * It will be used as `import client from '${client.importPath}'`.
-     * It allow both relative and absolute path.
-     * the path will be applied as is, so relative path shoule be based on the file being generated.
-     * @default '@kubb/plugin-client/client'
+     * Customize the queryKey, here you can specify a suffix.
+     */
+    key: (key: unknown[]) => unknown[]
+    /**
+     * Define which HttpMethods can be used for queries
+     * @default ['get']
+     */
+    methods?: Array<HttpMethod>
+    /**
+     * Path to the useQuery that will be used to do the useQuery functionality.
+     * It will be used as `import { useQuery } from '${importPath}'`.
+     * It allows both relative and absolute path.
+     * the path will be applied as is, so relative path should be based on the file being generated.
+     * @default '@tanstack/react-query' if 'framework' is set to 'react'
+     */
+    importPath?: string
+  }
+  mutation?: {
+    /**
+     * Customize the queryKey, here you can specify a suffix.
+     */
+    key: (key: unknown[]) => unknown[]
+    /**
+     * Define which HttpMethods can be used for queries
+     * @default ['post', 'put', 'delete', 'patch']
+     */
+    methods?: Array<HttpMethod>
+    /**
+     * Path to the useQuery that will be used to do the useQuery functionality.
+     * It will be used as `import { useQuery } from '${importPath}'`.
+     * It allows both relative and absolute path.
+     * the path will be applied as is, so relative path should be based on the file being generated.
+     * @default '@tanstack/react-query' if 'framework' is set to 'react'
      */
     importPath?: string
   }
   /**
-   * ReturnType that needs to be used when calling client().
+   * How to pass your pathParams.
    *
-   * `Data` will return ResponseConfig[data].
+   * `object` will return the pathParams as an object.
    *
-   * `Full` will return ResponseConfig.
-   * @default `'data'`
+   * `inline` will return the pathParams as comma separated params.
+   * @default `'inline'`
    * @private
    */
-  dataReturnType?: 'data' | 'full'
+  pathParamsType?: PluginClient['options']['pathParamsType']
+  /**
+   * Which parser can be used before returning the data to `swr`.
+   * `'zod'` will use `@kubb/plugin-zod` to parse the data.
+   */
+  parser?: PluginClient['options']['parser']
   transformers?: {
     /**
      * Customize the names based on the type that is provided by the plugin.
@@ -93,27 +85,19 @@ export type Options = {
     name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
   }
   /**
-   * Which parser can be used before returning the data to `@tanstack/query`.
-   * `'zod'` will use `@kubb/plugin-zod` to parse the data.
-   */
-  parser?: 'zod'
-  /**
-   * Make it possible to override one of the templates
+   * Define some generators next to the swr generators
    */
-  templates?: Partial<Templates>
+  generators?: Array<Generator<PluginSwr>>
 }
 
 type ResolvedOptions = {
-  extName: KubbFile.Extname | undefined
+  output: Output
+  baseURL: string | undefined
   client: Required<NonNullable<Options['client']>>
-  dataReturnType: NonNullable<Options['dataReturnType']>
-  templates: NonNullable<Templates>
-  parser: Options['parser']
-}
-
-export type FileMeta = {
-  pluginKey?: Plugin['key']
-  tag?: string
+  parser: Required<NonNullable<Options['parser']>>
+  mutation: Required<NonNullable<Options['mutation']>>
+  query: Required<NonNullable<Options['query']>>
+  pathParamsType: NonNullable<Options['pathParamsType']>
 }
 
 export type PluginSwr = PluginFactoryOptions<'plugin-swr', Options, ResolvedOptions, never, ResolvePathOptions>