@kubb/plugin-react-query 5.0.0-alpha.9 → 5.0.0-beta.100

package/src/plugin.ts

@@ -1,239 +0,0 @@
-import path from 'node:path'
-import { camelCase, pascalCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode } 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 } from './components'
-import { QueryKey } from './components/QueryKey.tsx'
-import {
-  customHookOptionsFileGenerator,
-  hookOptionsGenerator,
-  infiniteQueryGenerator,
-  mutationGenerator,
-  queryGenerator,
-  suspenseInfiniteQueryGenerator,
-  suspenseQueryGenerator,
-} from './generators'
-import type { PluginReactQuery } from './types.ts'
-
-export const pluginReactQueryName = 'plugin-react-query' satisfies PluginReactQuery['name']
-
-export const pluginReactQuery = createPlugin<PluginReactQuery>((options) => {
-  const {
-    output = { path: 'hooks', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    parser = 'client',
-    suspense = {},
-    infinite = false,
-    transformers = {},
-    paramsType = 'inline',
-    pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
-    generators = [
-      queryGenerator,
-      suspenseQueryGenerator,
-      infiniteQueryGenerator,
-      suspenseInfiniteQueryGenerator,
-      mutationGenerator,
-      hookOptionsGenerator,
-      customHookOptionsFileGenerator,
-    ].filter(Boolean),
-    mutation = {},
-    query = {},
-    mutationKey = MutationKey.getTransformer,
-    queryKey = QueryKey.getTransformer,
-    customOptions,
-    paramsCasing,
-    contentType,
-    client,
-  } = options
-
-  const clientName = client?.client ?? 'axios'
-  const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : undefined)
-
-  return {
-    name: pluginReactQueryName,
-    options: {
-      output,
-      client: {
-        bundle: client?.bundle,
-        baseURL: client?.baseURL,
-        client: clientName,
-        clientType: client?.clientType ?? 'function',
-        dataReturnType: client?.dataReturnType ?? 'data',
-        pathParamsType,
-        importPath: clientImportPath,
-        paramsCasing,
-      },
-      infinite: infinite
-        ? {
-            queryParam: 'id',
-            initialPageParam: 0,
-            cursorParam: undefined,
-            nextParam: undefined,
-            previousParam: undefined,
-            ...infinite,
-          }
-        : false,
-      suspense,
-      queryKey,
-      query:
-        query === false
-          ? false
-          : {
-              methods: ['get'],
-              importPath: '@tanstack/react-query',
-              ...query,
-            },
-      mutationKey,
-      mutation:
-        mutation === false
-          ? false
-          : {
-              methods: ['post', 'put', 'patch', 'delete'],
-              importPath: '@tanstack/react-query',
-              ...mutation,
-            },
-      customOptions: customOptions ? { name: 'useCustomHookOptions', ...customOptions } : undefined,
-      paramsType,
-      pathParamsType,
-      parser,
-      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)
-      }
-
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: Group['name'] = group?.name
-          ? group.name
-          : (ctx) => {
-              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: [],
-        })
-      }
-
-      if (!hasClientPlugin) {
-        await this.upsertFile({
-          baseName: 'config.ts',
-          path: path.resolve(root, '.kubb/config.ts'),
-          sources: [
-            {
-              name: 'config',
-              value: configSource,
-              isExportable: false,
-              isIndexable: false,
-            },
-          ],
-          imports: [],
-          exports: [],
-        })
-      }
-
-      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)
-    },
-  }
-})

package/src/types.ts

@@ -1,205 +0,0 @@
-import type { Transformer } from '@internals/tanstack-query'
-import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { contentType, HttpMethod, Oas } from '@kubb/oas'
-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'
-
-type Suspense = object
-
-/**
- * Customize the queryKey
- */
-type QueryKey = Transformer
-
-/**
- * Customize the mutationKey
- */
-type MutationKey = Transformer
-
-type Query = {
-  /**
-   * Define which HttpMethods can be used for queries
-   * @default ['get']
-   */
-  methods: Array<HttpMethod>
-  /**
-   * Path to the useQuery hook for useQuery functionality.
-   * Used as `import { useQuery } from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default '@tanstack/react-query'
-   */
-  importPath?: string
-}
-
-type Mutation = {
-  /**
-   * Define which HttpMethods can be used for mutations
-   * @default ['post', 'put', 'delete']
-   */
-  methods: Array<HttpMethod>
-  /**
-   * Path to the useQuery hook for useQuery functionality.
-   * Used as `import { useQuery } from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default '@tanstack/react-query'
-   */
-  importPath?: string
-}
-
-export type Infinite = {
-  /**
-   * Specify the params key used for `pageParam`.
-   * @default 'id'
-   */
-  queryParam: string
-  /**
-   * Which field of the data is used, set it to undefined when no cursor is known.
-   * @deprecated Use `nextParam` and `previousParam` instead for more flexible pagination handling.
-   */
-  cursorParam?: string | undefined
-  /**
-   * Which field of the data is used to get the cursor for the next page.
-   * Supports dot notation (e.g. 'pagination.next.id') or array path (e.g. ['pagination', 'next', 'id']) to access nested fields.
-   */
-  nextParam?: string | string[] | undefined
-  /**
-   * Which field of the data is used to get the cursor for the previous page.
-   * Supports dot notation (e.g. 'pagination.prev.id') or array path (e.g. ['pagination', 'prev', 'id']) to access nested fields.
-   */
-  previousParam?: string | string[] | undefined
-  /**
-   * The initial value, the value of the first page.
-   * @default 0
-   */
-  initialPageParam: unknown
-}
-
-type CustomOptions = {
-  /**
-   * Path to the hook that is used to customize the hook options.
-   * It used as `import ${customOptions.name} from '${customOptions.importPath}'`.
-   * It allows both relative and absolute paths but be aware that we will not change the path.
-   */
-  importPath: string
-  /**
-   * Name of the exported hook that is used to customize the hook options.
-   * It used as `import ${customOptions.name} from '${customOptions.importPath}'`.
-   * @default 'useCustomHookOptions'
-   */
-  name?: string
-}
-
-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
-  /**
-   * Group the @tanstack/query hooks based on the provided name.
-   */
-  group?: Group
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>
-  /**
-   * 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>>
-  /**
-   * How to style your params, by default no casing is applied
-   * - 'camelcase' uses camelcase for the params names
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * How to pass your params.
-   * - 'object' returns the params and pathParams as an object.
-   * - 'inline' returns the params as comma separated params.
-   * @default 'inline'
-   */
-  paramsType?: 'object' | 'inline'
-  /**
-   * How to pass your pathParams.
-   * - 'object' returns the pathParams as an object.
-   * - 'inline': returns the pathParams as comma separated params.
-   * @default 'inline'
-   */
-  pathParamsType?: PluginClient['options']['pathParamsType']
-
-  /**
-   * When set, an infiniteQuery hooks is added.
-   */
-  infinite?: Partial<Infinite> | false
-  /**
-   * When set, a suspenseQuery hooks is added.
-   */
-  suspense?: Partial<Suspense> | false
-  queryKey?: QueryKey
-  /**
-   * Override some useQuery behaviors.
-   */
-  query?: Partial<Query> | false
-  mutationKey?: MutationKey
-  /**
-   * Override some useMutation behaviors.
-   */
-  mutation?: Partial<Mutation> | false
-  /**
-   * When set, a custom hook is used to customize the options of the generated hooks.
-   * It will also generate a `HookOptions` type that can be used to type the custom options of each hook for type-safety.
-   */
-  customOptions?: CustomOptions
-  /**
-   * Which parser should be used before returning the data to `@tanstack/query`.
-   * `'zod'` uses `@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.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
-  }
-  /**
-   * Define some generators next to the react-query generators
-   */
-  generators?: Array<Generator<PluginReactQuery>>
-}
-
-type ResolvedOptions = {
-  output: Output<Oas>
-  group: Options['group']
-  client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>
-  parser: Required<NonNullable<Options['parser']>>
-  pathParamsType: NonNullable<Options['pathParamsType']>
-  paramsCasing: Options['paramsCasing']
-  paramsType: NonNullable<Options['paramsType']>
-  /**
-   * Only used of infinite
-   */
-  infinite: NonNullable<Infinite> | false
-  suspense: Suspense | false
-  queryKey: QueryKey | undefined
-  query: NonNullable<Required<Query>> | false
-  mutationKey: MutationKey | undefined
-  mutation: NonNullable<Required<Mutation>> | false
-  customOptions: NonNullable<Required<CustomOptions>> | undefined
-}
-
-export type PluginReactQuery = PluginFactoryOptions<'plugin-react-query', Options, ResolvedOptions, never, ResolvePathOptions>