@kubb/plugin-vue-query 5.0.0-alpha.9 → 5.0.0-beta.10

package/src/resolvers/resolverVueQuery.ts

@@ -0,0 +1,65 @@
+import { camelCase } from '@internals/utils'
+import { defineResolver } from '@kubb/core'
+import type { PluginVueQuery } from '../types.ts'
+
+function capitalize(name: string): string {
+  return `${name.charAt(0).toUpperCase()}${name.slice(1)}`
+}
+
+/**
+ * Naming convention resolver for Vue Query plugin.
+ *
+ * Provides default naming helpers using camelCase for functions and file paths.
+ */
+export const resolverVueQuery = defineResolver<PluginVueQuery>(() => ({
+  name: 'default',
+  pluginName: 'plugin-vue-query',
+  default(name, type) {
+    return camelCase(name, { isFile: type === 'file' })
+  },
+  resolveName(name) {
+    return this.default(name, 'function')
+  },
+  resolvePathName(name, type) {
+    return this.default(name, type)
+  },
+  resolveQueryName(node) {
+    return `use${capitalize(this.resolveName(node.operationId))}`
+  },
+  resolveInfiniteQueryName(node) {
+    return `use${capitalize(this.resolveName(node.operationId))}Infinite`
+  },
+  resolveMutationName(node) {
+    return `use${capitalize(this.resolveName(node.operationId))}`
+  },
+  resolveQueryOptionsName(node) {
+    return `${this.resolveName(node.operationId)}QueryOptions`
+  },
+  resolveInfiniteQueryOptionsName(node) {
+    return `${this.resolveName(node.operationId)}InfiniteQueryOptions`
+  },
+  resolveQueryKeyName(node) {
+    return `${this.resolveName(node.operationId)}QueryKey`
+  },
+  resolveInfiniteQueryKeyName(node) {
+    return `${this.resolveName(node.operationId)}InfiniteQueryKey`
+  },
+  resolveMutationKeyName(node) {
+    return `${this.resolveName(node.operationId)}MutationKey`
+  },
+  resolveQueryKeyTypeName(node) {
+    return `${capitalize(this.resolveName(node.operationId))}QueryKey`
+  },
+  resolveInfiniteQueryKeyTypeName(node) {
+    return `${capitalize(this.resolveName(node.operationId))}InfiniteQueryKey`
+  },
+  resolveMutationTypeName(node) {
+    return capitalize(this.resolveName(node.operationId))
+  },
+  resolveClientName(node) {
+    return this.resolveName(node.operationId)
+  },
+  resolveInfiniteClientName(node) {
+    return `${this.resolveName(node.operationId)}Infinite`
+  },
+}))

package/src/types.ts

@@ -1,50 +1,114 @@
-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 { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } 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'
+export type Transformer = (props: { node: ast.OperationNode; casing: 'camelcase' | undefined }) => unknown[]
 
 /**
- * Customize the queryKey
+ * Resolver for Vue Query that provides naming methods for hook functions.
+ */
+export type ResolverVueQuery = Resolver & {
+  /**
+   * Resolves the base function name for an operation.
+   */
+  resolveName(this: ResolverVueQuery, name: string): string
+  /**
+   * Resolves the output file name for a hook module.
+   */
+  resolvePathName(this: ResolverVueQuery, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
+  /**
+   * Resolves a query hook function name.
+   */
+  resolveQueryName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves an infinite query hook function name.
+   */
+  resolveInfiniteQueryName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves a mutation hook function name.
+   */
+  resolveMutationName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the query options helper name.
+   */
+  resolveQueryOptionsName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the infinite query options helper name.
+   */
+  resolveInfiniteQueryOptionsName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the query key helper name.
+   */
+  resolveQueryKeyName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the infinite query key helper name.
+   */
+  resolveInfiniteQueryKeyName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the mutation key helper name.
+   */
+  resolveMutationKeyName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the query key type name.
+   */
+  resolveQueryKeyTypeName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the infinite query key type name.
+   */
+  resolveInfiniteQueryKeyTypeName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the mutation type name.
+   */
+  resolveMutationTypeName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the client function name generated inline by query hooks.
+   */
+  resolveClientName(this: ResolverVueQuery, node: ast.OperationNode): string
+  /**
+   * Resolves the client function name generated inline by infinite query hooks.
+   */
+  resolveInfiniteClientName(this: ResolverVueQuery, node: ast.OperationNode): string
+}
+
+/**
+ * Customize the queryKey.
  */
 type QueryKey = Transformer
 
 /**
- * Customize the mutationKey
+ * Customize the mutationKey.
  */
 type MutationKey = Transformer
 
 type Query = {
   /**
-   * Define which HttpMethods can be used for queries
+   * HTTP methods to use for queries.
+   *
    * @default ['get']
    */
-  methods: Array<HttpMethod>
+  methods?: Array<string>
   /**
    * 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'
+   * @default '@tanstack/vue-query'
    */
   importPath?: string
 }
 
 type Mutation = {
   /**
-   * Define which HttpMethods can be used for mutations
+   * HTTP methods to use for mutations.
+   *
    * @default ['post', 'put', 'delete']
    */
-  methods: Array<HttpMethod>
+  methods?: Array<string>
   /**
-   * Path to the useQuery hook for useQuery functionality.
-   * Used as `import { useQuery } from '${importPath}'`.
+   * Path to the useMutation hook for useMutation functionality.
+   * Used as `import { useMutation } 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'
+   * @default '@tanstack/vue-query'
    */
   importPath?: string
 }
@@ -52,7 +116,7 @@ type Mutation = {
 export type Infinite = {
   /**
    * Specify the params key used for `pageParam`.
-   * @default `'id'`
+   * @default 'id'
    */
   queryParam: string
   /**
@@ -72,7 +136,7 @@ export type Infinite = {
   previousParam?: string | string[] | undefined
   /**
    * The initial value, the value of the first page.
-   * @default `0`
+   * @default 0
    */
   initialPageParam: unknown
 }
@@ -82,95 +146,100 @@ 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 @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.
+   * Tags, operations, or paths to exclude from generation.
    */
   exclude?: Array<Exclude>
   /**
-   * Array containing include parameters to include tags/operations/methods/paths.
+   * Tags, operations, or paths to include in generation.
    */
   include?: Array<Include>
   /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   * Override options for specific tags, operations, or paths.
    */
   override?: Array<Override<ResolvedOptions>>
   /**
-   * How to style your params, by default no casing is applied
-   * - 'camelcase' uses camelcase for the params names
+   * Apply casing to parameter 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.
+   * How parameters are passed: grouped in an object or spread inline.
+   *
    * @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.
+   * How path parameters are passed: grouped in an object or spread inline.
+   *
    * @default 'inline'
    */
   pathParamsType?: PluginClient['options']['pathParamsType']
   /**
-   * When set, an infiniteQuery hooks is added.
+   * Add infinite query hooks.
    */
   infinite?: Partial<Infinite> | false
   queryKey?: QueryKey
   /**
-   * Override some useQuery behaviors.
+   * Configure useQuery behavior.
    */
   query?: Partial<Query> | false
   mutationKey?: MutationKey
   /**
-   * Override some useMutation behaviors.
+   * Configure useMutation behavior.
    */
   mutation?: Partial<Mutation> | false
   /**
-   * Which parser should be used before returning the data to `@tanstack/query`.
-   * `'zod'` uses `@kubb/plugin-zod` to parse the data.
+   * Parser to use for validating response 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 vue-query generators
+   * Override naming conventions for function names and types.
+   */
+  resolver?: Partial<ResolverVueQuery> & ThisType<ResolverVueQuery>
+  /**
+   * AST visitor to transform generated nodes.
+   */
+  transformer?: ast.Visitor
+  /**
+   * Additional generators alongside the default generators.
    */
   generators?: Array<Generator<PluginVueQuery>>
 }
 
 type ResolvedOptions = {
-  output: Output<Oas>
-  group: Options['group']
+  output: Output
+  group: Group | undefined
+  exclude: NonNullable<Options['exclude']>
+  include: Options['include']
+  override: NonNullable<Options['override']>
   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']>
-  pathParamsType: NonNullable<Options['pathParamsType']>
   /**
-   * Only used of infinite
+   * Only used for infinite
    */
   infinite: NonNullable<Infinite> | false
   queryKey: QueryKey | undefined
   query: NonNullable<Required<Query>> | false
   mutationKey: MutationKey | undefined
   mutation: NonNullable<Required<Mutation>> | false
+  resolver: ResolverVueQuery
 }
 
-export type PluginVueQuery = PluginFactoryOptions<'plugin-vue-query', Options, ResolvedOptions, never, ResolvePathOptions>
+export type PluginVueQuery = PluginFactoryOptions<'plugin-vue-query', Options, ResolvedOptions, ResolverVueQuery>
+
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-vue-query': PluginVueQuery
+    }
+  }
+}

package/src/utils.ts

@@ -0,0 +1,49 @@
+export {
+  buildGroupParam,
+  buildQueryKeyParams,
+  resolveHeaderGroupType,
+  resolveOperationOverrides,
+  resolvePathParamType,
+  resolveQueryGroupType,
+  resolveZodSchemaNames,
+} from '@internals/tanstack-query'
+export { buildOperationComments as getComments, buildRequestConfigType, getContentTypeInfo, resolveErrorNames, resolveStatusCodeNames } from '@internals/shared'
+
+import { ast } from '@kubb/core'
+
+export function printType(typeNode: ast.ParamsTypeNode | undefined): string {
+  if (!typeNode) return 'unknown'
+  if (typeNode.variant === 'reference') return typeNode.name
+  if (typeNode.variant === 'member') return `${typeNode.base}['${typeNode.key}']`
+  if (typeNode.variant === 'struct') {
+    const parts = typeNode.properties.map((p) => {
+      const typeStr = printType(p.type)
+      const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name)
+      return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`
+    })
+    return `{ ${parts.join('; ')} }`
+  }
+  return 'unknown'
+}
+
+export function wrapWithMaybeRefOrGetter(paramsNode: ast.FunctionParametersNode, skip?: (name: string) => boolean): ast.FunctionParametersNode {
+  const wrappedParams = paramsNode.params.map((param) => {
+    if ('kind' in param && (param as ast.ParameterGroupNode).kind === 'ParameterGroup') {
+      const group = param as ast.ParameterGroupNode
+      return {
+        ...group,
+        properties: group.properties.map((p) => ({
+          ...p,
+          type: p.type ? ast.createParamsType({ variant: 'reference', name: `MaybeRefOrGetter<${printType(p.type)}>` }) : p.type,
+        })),
+      }
+    }
+    const fp = param as ast.FunctionParameterNode
+    if (skip?.(fp.name)) return fp
+    return {
+      ...fp,
+      type: fp.type ? ast.createParamsType({ variant: 'reference', name: `MaybeRefOrGetter<${printType(fp.type)}>` }) : fp.type,
+    }
+  })
+  return ast.createFunctionParameters({ params: wrappedParams })
+}