@kubb/plugin-swr 3.0.0-alpha.2 → 3.0.0-alpha.20

package/dist/types-BCd4p4VZ.d.cts

@@ -0,0 +1,127 @@
+import { PluginFactoryOptions, Output, ResolveNameParams } from '@kubb/core';
+import { HttpMethod } from '@kubb/oas';
+import { ResolvePathOptions, Exclude, Include, Override } from '@kubb/plugin-oas';
+
+type Options = {
+    /**
+     * @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;
+    };
+    /**
+     * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+     */
+    exclude?: Array<Exclude>;
+    /**
+     * Array containing include parameters to include tags/operations/methods/paths.
+     */
+    include?: Array<Include>;
+    /**
+     * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+     */
+    override?: Array<Override<ResolvedOptions>>;
+    client?: {
+        /**
+         * 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 allows 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'
+         */
+        importPath?: string;
+        /**
+         * ReturnType that needs to be used when calling client().
+         *
+         * `Data` will return ResponseConfig[data].
+         *
+         * `Full` will return ResponseConfig.
+         * @default `'data'`
+         * @private
+         */
+        dataReturnType?: 'data' | 'full';
+    };
+    query?: {
+        /**
+         * 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?: {
+        /**
+         * 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;
+    };
+    /**
+     * How to pass your pathParams.
+     *
+     * `object` will return the pathParams as an object.
+     *
+     * `inline` will return the pathParams as comma separated params.
+     * @default `'inline'`
+     * @private
+     */
+    pathParamsType?: 'object' | 'inline';
+    /**
+     * Which parser can be used before returning the data to `swr`.
+     * `'zod'` will use `@kubb/plugin-zod` to parse the data.
+     */
+    parser?: 'client' | 'zod';
+    transformers?: {
+        /**
+         * Customize the names based on the type that is provided by the plugin.
+         */
+        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    };
+};
+type ResolvedOptions = {
+    output: Output;
+    baseURL: string | undefined;
+    client: Required<NonNullable<Options['client']>>;
+    parser: Required<NonNullable<Options['parser']>>;
+    mutation: Required<NonNullable<Options['mutation']>>;
+    query: Required<NonNullable<Options['query']>>;
+    pathParamsType: NonNullable<Options['pathParamsType']>;
+};
+type PluginSwr = PluginFactoryOptions<'plugin-swr', Options, ResolvedOptions, never, ResolvePathOptions>;
+
+export type { Options as O, PluginSwr as P };

package/dist/types-BCd4p4VZ.d.ts

@@ -0,0 +1,127 @@
+import { PluginFactoryOptions, Output, ResolveNameParams } from '@kubb/core';
+import { HttpMethod } from '@kubb/oas';
+import { ResolvePathOptions, Exclude, Include, Override } from '@kubb/plugin-oas';
+
+type Options = {
+    /**
+     * @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;
+    };
+    /**
+     * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+     */
+    exclude?: Array<Exclude>;
+    /**
+     * Array containing include parameters to include tags/operations/methods/paths.
+     */
+    include?: Array<Include>;
+    /**
+     * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+     */
+    override?: Array<Override<ResolvedOptions>>;
+    client?: {
+        /**
+         * 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 allows 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'
+         */
+        importPath?: string;
+        /**
+         * ReturnType that needs to be used when calling client().
+         *
+         * `Data` will return ResponseConfig[data].
+         *
+         * `Full` will return ResponseConfig.
+         * @default `'data'`
+         * @private
+         */
+        dataReturnType?: 'data' | 'full';
+    };
+    query?: {
+        /**
+         * 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?: {
+        /**
+         * 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;
+    };
+    /**
+     * How to pass your pathParams.
+     *
+     * `object` will return the pathParams as an object.
+     *
+     * `inline` will return the pathParams as comma separated params.
+     * @default `'inline'`
+     * @private
+     */
+    pathParamsType?: 'object' | 'inline';
+    /**
+     * Which parser can be used before returning the data to `swr`.
+     * `'zod'` will use `@kubb/plugin-zod` to parse the data.
+     */
+    parser?: 'client' | 'zod';
+    transformers?: {
+        /**
+         * Customize the names based on the type that is provided by the plugin.
+         */
+        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    };
+};
+type ResolvedOptions = {
+    output: Output;
+    baseURL: string | undefined;
+    client: Required<NonNullable<Options['client']>>;
+    parser: Required<NonNullable<Options['parser']>>;
+    mutation: Required<NonNullable<Options['mutation']>>;
+    query: Required<NonNullable<Options['query']>>;
+    pathParamsType: NonNullable<Options['pathParamsType']>;
+};
+type PluginSwr = PluginFactoryOptions<'plugin-swr', Options, ResolvedOptions, never, ResolvePathOptions>;
+
+export type { Options as O, PluginSwr as P };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-swr",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.20",
   "description": "Generator plugin-swr",
   "keywords": [
     "typescript",
@@ -30,6 +30,11 @@
       "require": "./dist/index.cjs",
       "default": "./dist/index.cjs"
     },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs",
+      "default": "./dist/generators.cjs"
+    },
     "./components": {
       "import": "./dist/components.js",
       "require": "./dist/components.cjs",
@@ -45,6 +50,9 @@
     "*": {
       "components": [
         "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
       ]
     }
   },
@@ -55,27 +63,25 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
-    "@kubb/core": "3.0.0-alpha.2",
-    "@kubb/fs": "3.0.0-alpha.2",
-    "@kubb/oas": "3.0.0-alpha.2",
-    "@kubb/parser-ts": "3.0.0-alpha.2",
-    "@kubb/plugin-client": "3.0.0-alpha.2",
-    "@kubb/plugin-oas": "3.0.0-alpha.2",
-    "@kubb/plugin-ts": "3.0.0-alpha.2",
-    "@kubb/plugin-zod": "3.0.0-alpha.2",
-    "@kubb/react": "3.0.0-alpha.2"
+    "@kubb/core": "3.0.0-alpha.20",
+    "@kubb/fs": "3.0.0-alpha.20",
+    "@kubb/oas": "3.0.0-alpha.20",
+    "@kubb/plugin-client": "3.0.0-alpha.20",
+    "@kubb/plugin-oas": "3.0.0-alpha.20",
+    "@kubb/plugin-ts": "3.0.0-alpha.20",
+    "@kubb/plugin-zod": "3.0.0-alpha.20",
+    "@kubb/react": "3.0.0-alpha.20"
   },
   "devDependencies": {
-    "@types/react": "^18.3.4",
+    "@types/react": "^18.3.6",
     "react": "^18.3.1",
     "tsup": "^8.2.4",
-    "typescript": "^5.5.4",
-    "@kubb/config-biome": "3.0.0-alpha.2",
-    "@kubb/config-ts": "3.0.0-alpha.2",
-    "@kubb/config-tsup": "3.0.0-alpha.2"
+    "typescript": "^5.6.2",
+    "@kubb/config-ts": "3.0.0-alpha.20",
+    "@kubb/config-tsup": "3.0.0-alpha.20"
   },
   "peerDependencies": {
-    "@kubb/react": "3.0.0-alpha.2"
+    "@kubb/react": "3.0.0-alpha.20"
   },
   "engines": {
     "node": ">=20"

package/src/components/Mutation.tsx

@@ -1,252 +1,107 @@
-import transformers from '@kubb/core/transformers'
-import { FunctionParams, URLPath } from '@kubb/core/utils'
-import { Parser, File, Function, useApp } from '@kubb/react'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getASTParams, getComments } from '@kubb/plugin-oas/utils'
+import { URLPath } from '@kubb/core/utils'
+import { File, Function, FunctionParams } from '@kubb/react'
 
-import { SchemaType } from './SchemaType.tsx'
-
-import type { HttpMethod } from '@kubb/oas'
+import { type Operation, isOptional } from '@kubb/oas'
+import { Client } from '@kubb/plugin-client/components'
+import type { OperationSchemas } from '@kubb/plugin-oas'
+import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
 import type { ReactNode } from 'react'
-import type { FileMeta, PluginSwr } from '../types.ts'
+import type { PluginSwr } from '../types.ts'
 
-type TemplateProps = {
+type Props = {
   /**
    * Name of the function
    */
   name: string
-  /**
-   * Parameters/options/props that need to be used
-   */
-  params: string
-  /**
-   * Generics that needs to be added for TypeScript
-   */
-  generics?: string
-  /**
-   * ReturnType(see async for adding Promise type)
-   */
-  returnType?: string
-  /**
-   * Options for JSdocs
-   */
-  JSDoc?: {
-    comments: string[]
-  }
-  hook: {
-    name: string
-    generics?: string
-  }
-  client: {
-    method: HttpMethod
-    generics: string
-    withQueryParams: boolean
-    withPathParams: boolean
-    withData: boolean
-    withHeaders: boolean
-    path: URLPath
-  }
-  dataReturnType: NonNullable<PluginSwr['options']['dataReturnType']>
+  typeName: string
+  clientName: string
+  typeSchemas: OperationSchemas
+  operation: Operation
+  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
+  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
 }
 
-function Template({ name, generics, returnType, params, JSDoc, client, hook, dataReturnType }: TemplateProps): ReactNode {
-  const clientOptions = [
-    `method: "${client.method}"`,
-    'url',
-    client.withQueryParams ? 'params' : undefined,
-    client.withData ? 'data' : undefined,
-    client.withHeaders ? 'headers: { ...headers, ...clientOptions.headers }' : undefined,
-    '...clientOptions',
-  ].filter(Boolean)
-
-  const resolvedClientOptions = `${transformers.createIndent(4)}${clientOptions.join(`,\n${transformers.createIndent(4)}`)}`
-  if (client.withQueryParams) {
-    return (
-      <Function export name={name} generics={generics} returnType={returnType} params={params} JSDoc={JSDoc}>
-        {`
-         const { mutation: mutationOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
-
-         const url = ${client.path.template} as const
-         return ${hook.name}<${hook.generics}>(
-          shouldFetch ? [url, params]: null,
-          async (_url${client.withData ? ', { arg: data }' : ''}) => {
-            const res = await client<${client.generics}>({
-              ${resolvedClientOptions}
-            })
-
-            return ${dataReturnType === 'data' ? 'res.data' : 'res'}
-          },
-          mutationOptions
-        )
-      `}
-      </Function>
-    )
-  }
-  return (
-    <Function export name={name} generics={generics} returnType={returnType} params={params} JSDoc={JSDoc}>
-      {`
-       const { mutation: mutationOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
-
-       const url = ${client.path.template} as const
-       return ${hook.name}<${hook.generics}>(
-        shouldFetch ? url : null,
-        async (_url${client.withData ? ', { arg: data }' : ''}) => {
-          const res = await client<${client.generics}>({
-            ${resolvedClientOptions}
-          })
-
-          return ${dataReturnType === 'data' ? 'res.data' : 'res'}
-        },
-        mutationOptions
-      )
-    `}
-    </Function>
-  )
+type GetParamsProps = {
+  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
+  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
+  typeSchemas: OperationSchemas
 }
 
-const defaultTemplates = {
-  default: Template,
-} as const
+function getParams({ pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
+  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
 
-type Props = {
-  factory: {
-    name: string
-  }
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  Template?: React.ComponentType<TemplateProps>
-}
-
-export function Mutation({ factory, Template = defaultTemplates.default }: Props): ReactNode {
-  const {
-    plugin: {
-      options: { dataReturnType },
-    },
-  } = useApp<PluginSwr>()
-  const { getSchemas, getName } = useOperationManager()
-  const operation = useOperation()
-
-  const name = getName(operation, { type: 'function' })
-  const schemas = getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' })
-
-  const params = new FunctionParams()
-  const client = {
-    method: operation.method,
-    path: new URLPath(operation.path),
-    generics: [`${factory.name}["data"]`, `${factory.name}["error"]`, schemas.request?.name ? `${factory.name}["request"]` : ''].filter(Boolean).join(', '),
-    withQueryParams: !!schemas.queryParams?.name,
-    withData: !!schemas.request?.name,
-    withPathParams: !!schemas.pathParams?.name,
-    withHeaders: !!schemas.headerParams?.name,
-  }
-
-  const resultGenerics = [`${factory.name}["response"]`, `${factory.name}["error"]`]
-
-  params.add([
-    ...getASTParams(schemas.pathParams, { typed: true }),
-    {
-      name: 'params',
-      type: `${factory.name}['queryParams']`,
-      enabled: client.withQueryParams,
-      required: false,
+  return FunctionParams.factory({
+    pathParams: {
+      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
+      children: getPathParams(typeSchemas.pathParams, { typed: true }),
     },
-    {
-      name: 'headers',
-      type: `${factory.name}['headerParams']`,
-      enabled: client.withHeaders,
-      required: false,
-    },
-    {
-      name: 'options',
-      required: false,
-      type: `{
-        mutation?: SWRMutationConfiguration<${resultGenerics.join(', ')}>,
-        client?: ${factory.name}['client']['parameters'],
-        shouldFetch?: boolean,
-      }`,
+    params: typeSchemas.queryParams?.name
+      ? {
+          type: typeSchemas.queryParams?.name,
+          optional: isOptional(typeSchemas.queryParams?.schema),
+        }
+      : undefined,
+    headers: typeSchemas.headerParams?.name
+      ? {
+          type: typeSchemas.headerParams?.name,
+          optional: isOptional(typeSchemas.headerParams?.schema),
+        }
+      : undefined,
+    options: {
+      type: `
+{
+  mutation?: SWRMutationConfiguration<${[TData, typeSchemas.errors?.map((item) => item.name).join(' | ') || 'unknown'].join(', ')}>,
+  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>>` : 'Partial<RequestConfig>'},
+  shouldFetch?: boolean,
+}
+`,
       default: '{}',
     },
-  ])
-
-  const hook = {
-    name: 'useSWRMutation',
-    generics: [...resultGenerics, client.withQueryParams ? '[typeof url, typeof params] | null' : 'typeof url | null'].join(', '),
-  }
-
-  return (
-    <Template
-      name={name}
-      JSDoc={{ comments: getComments(operation) }}
-      client={client}
-      hook={hook}
-      params={params.toString()}
-      returnType={`SWRMutationResponse<${resultGenerics.join(', ')}>`}
-      dataReturnType={dataReturnType}
-    />
-  )
+  })
 }
 
-type FileProps = {
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  templates?: typeof defaultTemplates
-}
+export function Mutation({ name, clientName, pathParamsType, dataReturnType, typeSchemas, operation }: Props): ReactNode {
+  const path = new URLPath(operation.path)
+  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
+  const hookGenerics = [TData, typeSchemas.errors?.map((item) => item.name).join(' | ') || 'unknown', 'Key']
 
-Mutation.File = function ({ templates = defaultTemplates }: FileProps): ReactNode {
-  const {
-    plugin: {
-      options: {
-        extName,
-        client: { importPath },
-      },
-    },
-  } = useApp<PluginSwr>()
-
-  const { getSchemas, getFile, getName } = useOperationManager()
-  const operation = useOperation()
+  const params = getParams({
+    pathParamsType,
+    dataReturnType,
+    typeSchemas,
+  })
 
-  const schemas = getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' })
-  const file = getFile(operation)
-  const fileType = getFile(operation, { pluginKey: [pluginTsName] })
-  const factoryName = getName(operation, { type: 'type' })
+  const clientParams = Client.getParams({
+    typeSchemas,
+    pathParamsType,
+  })
 
-  const Template = templates.default
-  const factory = {
-    name: factoryName,
-  }
+  //fixed name, see Query.getParams and params
+  const swrKey = [path.template, typeSchemas.queryParams?.name ? 'params' : undefined].filter(Boolean)
 
   return (
-    <Parser language="typescript">
-      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-        <File.Import name="useSWRMutation" path="swr/mutation" />
-        <File.Import name={['SWRMutationConfiguration', 'SWRMutationResponse']} path="swr/mutation" isTypeOnly />
-        <File.Import name={'client'} path={importPath} />
-        <File.Import name={['ResponseConfig']} path={importPath} isTypeOnly />
-        <File.Import
-          extName={extName}
-          name={[
-            schemas.request?.name,
-            schemas.response.name,
-            schemas.pathParams?.name,
-            schemas.queryParams?.name,
-            schemas.headerParams?.name,
-            ...(schemas.errors?.map((error) => error.name) || []),
-          ].filter(Boolean)}
-          root={file.path}
-          path={fileType.path}
-          isTypeOnly
-        />
+    <File.Source name={name} isExportable isIndexable>
+      <Function
+        name={name}
+        export
+        params={params.toConstructor()}
+        JSDoc={{
+          comments: getComments(operation),
+        }}
+      >
+        {`
+       const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
 
-        <File.Source>
-          <SchemaType factory={factory} />
-          <Mutation Template={Template} factory={factory} />
-        </File.Source>
-      </File>
-    </Parser>
+        const swrKey = [${swrKey.join(', ')}] as const
+        return useSWRMutation<${hookGenerics}>(
+        shouldFetch ? swrKey : null,
+        async (_url${typeSchemas.request?.name ? ', { arg: data }' : ''}) => {
+          return ${clientName}(${clientParams.toCall()})
+        },
+        mutationOptions
+      )
+    `}
+      </Function>
+    </File.Source>
   )
 }
-
-Mutation.templates = defaultTemplates