@kubb/plugin-vue-query 3.1.0 → 3.2.0

package/dist/{types-DAqaLrlX.d.ts → types-BeGGMRuk.d.ts}

@@ -47,6 +47,11 @@ type Options$2 = {
      * @default 'data'
      */
     dataReturnType?: 'data' | 'full';
+    /**
+     * How to style your params, by default no casing is applied
+     * - 'camelcase' will use camelcase for the params names
+     */
+    paramsCasing?: 'camelcase';
     /**
      * How to pass your params
      * - 'object' will return the params and pathParams as an object.
@@ -87,12 +92,14 @@ type ResolvedOptions$2 = {
     dataReturnType: NonNullable<Options$2['dataReturnType']>;
     pathParamsType: NonNullable<Options$2['pathParamsType']>;
     paramsType: NonNullable<Options$2['paramsType']>;
+    paramsCasing: Options$2['paramsCasing'];
 };
 type PluginClient = PluginFactoryOptions<'plugin-client', Options$2, ResolvedOptions$2, never, ResolvePathOptions>;
 
 type TransformerProps$1 = {
     operation: Operation;
     schemas: OperationSchemas;
+    casing: 'camelcase' | undefined;
 };
 type Transformer$1 = (props: TransformerProps$1) => unknown[];
 type Suspense = object;
@@ -173,6 +180,11 @@ type Options$1 = {
      * Array containing override parameters to override `options` based on tags/operations/methods/paths.
      */
     override?: Array<Override<ResolvedOptions$1>>;
+    /**
+     * How to style your params, by default no casing is applied
+     * - 'camelcase' will use camelcase for the params names
+     */
+    paramsCasing?: 'camelcase';
     /**
      * How to pass your params
      * - 'object' will return the params and pathParams as an object.
@@ -229,6 +241,7 @@ type ResolvedOptions$1 = {
     };
     parser: Required<NonNullable<Options$1['parser']>>;
     pathParamsType: NonNullable<Options$1['pathParamsType']>;
+    paramsCasing: Options$1['paramsCasing'];
     paramsType: NonNullable<Options$1['paramsType']>;
     /**
      * Only used of infinite
@@ -245,6 +258,7 @@ type PluginReactQuery = PluginFactoryOptions<'plugin-react-query', Options$1, Re
 type TransformerProps = {
     operation: Operation;
     schemas: OperationSchemas;
+    casing: 'camelcase' | undefined;
 };
 type Transformer = (props: TransformerProps) => unknown[];
 /**
@@ -324,6 +338,11 @@ type Options = {
      * 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' will use camelcase for the params names
+     */
+    paramsCasing?: 'camelcase';
     /**
      * How to pass your params
      * - 'object' will return the params and pathParams as an object.
@@ -375,6 +394,7 @@ type ResolvedOptions = {
         baseURL?: string;
     };
     parser: Required<NonNullable<Options['parser']>>;
+    paramsCasing: Options['paramsCasing'];
     paramsType: NonNullable<Options['paramsType']>;
     pathParamsType: NonNullable<Options['pathParamsType']>;
     /**
@@ -388,4 +408,4 @@ type ResolvedOptions = {
 };
 type PluginVueQuery = PluginFactoryOptions<'plugin-vue-query', Options, ResolvedOptions, never, ResolvePathOptions>;
 
-export type { Infinite as I, Options as O, PluginVueQuery as P, Transformer as T };
+export type { Infinite as I, Options as O, PluginVueQuery as P, Transformer as T, PluginReactQuery as a };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-vue-query",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Generator vue-query hooks",
   "keywords": [
     "faker",
@@ -63,21 +63,21 @@
   ],
   "dependencies": {
     "remeda": "^2.17.4",
-    "@kubb/core": "3.1.0",
-    "@kubb/fs": "3.1.0",
-    "@kubb/oas": "3.1.0",
-    "@kubb/plugin-oas": "3.1.0",
-    "@kubb/plugin-ts": "3.1.0",
-    "@kubb/plugin-zod": "3.1.0",
-    "@kubb/react": "3.1.0"
+    "@kubb/core": "3.2.0",
+    "@kubb/fs": "3.2.0",
+    "@kubb/oas": "3.2.0",
+    "@kubb/plugin-oas": "3.2.0",
+    "@kubb/plugin-ts": "3.2.0",
+    "@kubb/plugin-zod": "3.2.0",
+    "@kubb/react": "3.2.0"
   },
   "devDependencies": {
-    "@types/react": "^18.3.13",
+    "@types/react": "^18.3.16",
     "react": "^18.3.1",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "@kubb/config-ts": "3.1.0",
-    "@kubb/config-tsup": "3.1.0"
+    "@kubb/config-ts": "3.2.0",
+    "@kubb/config-tsup": "3.2.0"
   },
   "peerDependencies": {
     "@kubb/react": "^3.0.0"

package/src/components/InfiniteQuery.tsx

@@ -18,19 +18,21 @@ type Props = {
   queryKeyTypeName: string
   typeSchemas: OperationSchemas
   operation: Operation
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
 }
 
 type GetParamsProps = {
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
   typeSchemas: OperationSchemas
 }
 
-function getParams({ paramsType, pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
+function getParams({ paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
   const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
 
   if (paramsType === 'object') {
@@ -40,6 +42,7 @@ function getParams({ paramsType, pathParamsType, dataReturnType, typeSchemas }:
         children: {
           ...getPathParams(typeSchemas.pathParams, {
             typed: true,
+            casing: paramsCasing,
             override(item) {
               return {
                 ...item,
@@ -85,6 +88,7 @@ function getParams({ paramsType, pathParamsType, dataReturnType, typeSchemas }:
       optional: isOptional(typeSchemas.pathParams?.schema),
       children: getPathParams(typeSchemas.pathParams, {
         typed: true,
+        casing: paramsCasing,
         override(item) {
           return {
             ...item,
@@ -130,6 +134,7 @@ export function InfiniteQuery({
   queryKeyName,
   paramsType,
   pathParamsType,
+  paramsCasing,
   dataReturnType,
   typeSchemas,
   operation,
@@ -141,13 +146,16 @@ export function InfiniteQuery({
   const queryKeyParams = QueryKey.getParams({
     pathParamsType,
     typeSchemas,
+    paramsCasing,
   })
   const queryOptionsParams = QueryOptions.getParams({
     paramsType,
     pathParamsType,
     typeSchemas,
+    paramsCasing,
   })
   const params = getParams({
+    paramsCasing,
     paramsType,
     pathParamsType,
     dataReturnType,

package/src/components/InfiniteQueryOptions.tsx

@@ -14,6 +14,7 @@ type Props = {
   clientName: string
   queryKeyName: string
   typeSchemas: OperationSchemas
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
@@ -23,12 +24,13 @@ type Props = {
 }
 
 type GetParamsProps = {
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   typeSchemas: OperationSchemas
 }
 
-function getParams({ paramsType, pathParamsType, typeSchemas }: GetParamsProps) {
+function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas }: GetParamsProps) {
   if (paramsType === 'object') {
     return FunctionParams.factory({
       data: {
@@ -36,6 +38,7 @@ function getParams({ paramsType, pathParamsType, typeSchemas }: GetParamsProps)
         children: {
           ...getPathParams(typeSchemas.pathParams, {
             typed: true,
+            casing: paramsCasing,
             override(item) {
               return {
                 ...item,
@@ -76,6 +79,7 @@ function getParams({ paramsType, pathParamsType, typeSchemas }: GetParamsProps)
       optional: isOptional(typeSchemas.pathParams?.schema),
       children: getPathParams(typeSchemas.pathParams, {
         typed: true,
+        casing: paramsCasing,
         override(item) {
           return {
             ...item,
@@ -116,18 +120,21 @@ export function InfiniteQueryOptions({
   cursorParam,
   typeSchemas,
   paramsType,
+  paramsCasing,
   dataReturnType,
   pathParamsType,
   queryParam,
   queryKeyName,
 }: Props): ReactNode {
-  const params = getParams({ paramsType, pathParamsType, typeSchemas })
+  const params = getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas })
   const clientParams = Client.getParams({
     paramsType,
+    paramsCasing,
     typeSchemas,
     pathParamsType,
   })
   const queryKeyParams = QueryKey.getParams({
+    paramsCasing,
     pathParamsType,
     typeSchemas,
   })

package/src/components/Mutation.tsx

@@ -19,22 +19,25 @@ type Props = {
   mutationKeyName: string
   typeSchemas: OperationSchemas
   operation: Operation
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
 }
 
 type GetParamsProps = {
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
   typeSchemas: OperationSchemas
 }
 
-function getParams({ dataReturnType, typeSchemas }: GetParamsProps) {
+function getParams({ paramsCasing, dataReturnType, typeSchemas }: GetParamsProps) {
   const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
   const mutationParams = FunctionParams.factory({
     ...getPathParams(typeSchemas.pathParams, {
       typed: true,
+      casing: paramsCasing,
       override(item) {
         return {
           ...item,
@@ -76,26 +79,38 @@ function getParams({ dataReturnType, typeSchemas }: GetParamsProps) {
   })
 }
 
-export function Mutation({ name, clientName, paramsType, pathParamsType, dataReturnType, typeSchemas, operation, mutationKeyName }: Props): ReactNode {
+export function Mutation({
+  name,
+  clientName,
+  paramsCasing,
+  paramsType,
+  pathParamsType,
+  dataReturnType,
+  typeSchemas,
+  operation,
+  mutationKeyName,
+}: Props): ReactNode {
   const mutationKeyParams = MutationKey.getParams({
     pathParamsType,
     typeSchemas,
   })
 
   const params = getParams({
+    paramsCasing,
     pathParamsType,
     dataReturnType,
     typeSchemas,
   })
 
   const clientParams = Client.getParams({
+    paramsCasing,
     paramsType,
     typeSchemas,
     pathParamsType,
   })
 
   const mutationParams = FunctionParams.factory({
-    ...getPathParams(typeSchemas.pathParams, { typed: true }),
+    ...getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
     data: typeSchemas.request?.name
       ? {
           type: typeSchemas.request?.name,

package/src/components/MutationKey.tsx

@@ -11,6 +11,7 @@ type Props = {
   typeName: string
   typeSchemas: OperationSchemas
   operation: Operation
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   transformer: Transformer | undefined
 }
@@ -24,15 +25,15 @@ function getParams({}: GetParamsProps) {
   return FunctionParams.factory({})
 }
 
-const getTransformer: Transformer = ({ operation }) => {
-  const path = new URLPath(operation.path)
+const getTransformer: Transformer = ({ operation, casing }) => {
+  const path = new URLPath(operation.path, { casing })
 
   return [JSON.stringify({ url: path.path })].filter(Boolean)
 }
 
-export function MutationKey({ name, typeSchemas, pathParamsType, operation, typeName, transformer = getTransformer }: Props): ReactNode {
+export function MutationKey({ name, typeSchemas, paramsCasing, pathParamsType, operation, typeName, transformer = getTransformer }: Props): ReactNode {
   const params = getParams({ pathParamsType, typeSchemas })
-  const keys = transformer({ operation, schemas: typeSchemas })
+  const keys = transformer({ operation, schemas: typeSchemas, casing: paramsCasing })
 
   return (
     <>

package/src/components/Query.tsx

@@ -19,19 +19,21 @@ type Props = {
   queryKeyTypeName: string
   typeSchemas: OperationSchemas
   operation: Operation
+  paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
 }
 
 type GetParamsProps = {
+  paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
   typeSchemas: OperationSchemas
 }
 
-function getParams({ paramsType, pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
+function getParams({ paramsCasing, paramsType, pathParamsType, dataReturnType, typeSchemas }: GetParamsProps) {
   const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
 
   if (paramsType === 'object') {
@@ -41,6 +43,7 @@ function getParams({ paramsType, pathParamsType, dataReturnType, typeSchemas }:
         children: {
           ...getPathParams(typeSchemas.pathParams, {
             typed: true,
+            casing: paramsCasing,
             override(item) {
               return {
                 ...item,
@@ -86,6 +89,7 @@ function getParams({ paramsType, pathParamsType, dataReturnType, typeSchemas }:
       optional: isOptional(typeSchemas.pathParams?.schema),
       children: getPathParams(typeSchemas.pathParams, {
         typed: true,
+        casing: paramsCasing,
         override(item) {
           return {
             ...item,
@@ -130,6 +134,7 @@ export function Query({
   queryOptionsName,
   queryKeyName,
   paramsType,
+  paramsCasing,
   pathParamsType,
   dataReturnType,
   typeSchemas,
@@ -142,13 +147,16 @@ export function Query({
   const queryKeyParams = QueryKey.getParams({
     pathParamsType,
     typeSchemas,
+    paramsCasing,
   })
   const queryOptionsParams = QueryOptions.getParams({
     paramsType,
     pathParamsType,
     typeSchemas,
+    paramsCasing,
   })
   const params = getParams({
+    paramsCasing,
     paramsType,
     pathParamsType,
     dataReturnType,

package/src/components/QueryKey.tsx

@@ -12,21 +12,24 @@ type Props = {
   typeName: string
   typeSchemas: OperationSchemas
   operation: Operation
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   transformer: Transformer | undefined
 }
 
 type GetParamsProps = {
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   typeSchemas: OperationSchemas
 }
 
-function getParams({ pathParamsType, typeSchemas }: GetParamsProps) {
+function getParams({ pathParamsType, paramsCasing, typeSchemas }: GetParamsProps) {
   return FunctionParams.factory({
     pathParams: {
       mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
       children: getPathParams(typeSchemas.pathParams, {
         typed: true,
+        casing: paramsCasing,
         override(item) {
           return {
             ...item,
@@ -50,8 +53,8 @@ function getParams({ pathParamsType, typeSchemas }: GetParamsProps) {
   })
 }
 
-const getTransformer: Transformer = ({ operation, schemas }) => {
-  const path = new URLPath(operation.path)
+const getTransformer: Transformer = ({ operation, schemas, casing }) => {
+  const path = new URLPath(operation.path, { casing })
   const keys = [
     path.toObject({
       type: 'path',
@@ -64,11 +67,12 @@ const getTransformer: Transformer = ({ operation, schemas }) => {
   return keys
 }
 
-export function QueryKey({ name, typeSchemas, pathParamsType, operation, typeName, transformer = getTransformer }: Props): ReactNode {
-  const params = getParams({ pathParamsType, typeSchemas })
+export function QueryKey({ name, typeSchemas, paramsCasing, pathParamsType, operation, typeName, transformer = getTransformer }: Props): ReactNode {
+  const params = getParams({ pathParamsType, typeSchemas, paramsCasing })
   const keys = transformer({
     operation,
     schemas: typeSchemas,
+    casing: paramsCasing,
   })
 
   return (

package/src/components/QueryOptions.tsx

@@ -15,17 +15,19 @@ type Props = {
   clientName: string
   queryKeyName: string
   typeSchemas: OperationSchemas
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
 }
 
 type GetParamsProps = {
+  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
   typeSchemas: OperationSchemas
 }
 
-function getParams({ paramsType, pathParamsType, typeSchemas }: GetParamsProps) {
+function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas }: GetParamsProps) {
   if (paramsType === 'object') {
     return FunctionParams.factory({
       data: {
@@ -33,6 +35,7 @@ function getParams({ paramsType, pathParamsType, typeSchemas }: GetParamsProps)
         children: {
           ...getPathParams(typeSchemas.pathParams, {
             typed: true,
+            casing: paramsCasing,
             override(item) {
               return {
                 ...item,
@@ -73,6 +76,7 @@ function getParams({ paramsType, pathParamsType, typeSchemas }: GetParamsProps)
       optional: isOptional(typeSchemas.pathParams?.schema),
       children: getPathParams(typeSchemas.pathParams, {
         typed: true,
+        casing: paramsCasing,
         override(item) {
           return {
             ...item,
@@ -106,16 +110,18 @@ function getParams({ paramsType, pathParamsType, typeSchemas }: GetParamsProps)
   })
 }
 
-export function QueryOptions({ name, clientName, typeSchemas, paramsType, pathParamsType, queryKeyName }: Props): ReactNode {
-  const params = getParams({ paramsType, pathParamsType, typeSchemas })
+export function QueryOptions({ name, clientName, typeSchemas, paramsCasing, paramsType, pathParamsType, queryKeyName }: Props): ReactNode {
+  const params = getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas })
   const clientParams = Client.getParams({
     paramsType,
+    paramsCasing,
     typeSchemas,
     pathParamsType,
   })
   const queryKeyParams = QueryKey.getParams({
     pathParamsType,
     typeSchemas,
+    paramsCasing,
   })
 
   const enabled = Object.entries(queryKeyParams.flatParams)

package/src/generators/infiniteQueryGenerator.tsx

@@ -85,6 +85,7 @@ export const infiniteQueryGenerator = createReactGenerator<PluginVueQuery>({
           name={queryKey.name}
           typeName={queryKey.typeName}
           operation={operation}
+          paramsCasing={options.paramsCasing}
           pathParamsType={options.pathParamsType}
           typeSchemas={type.schemas}
           transformer={options.queryKey}
@@ -98,6 +99,7 @@ export const infiniteQueryGenerator = createReactGenerator<PluginVueQuery>({
           typeSchemas={type.schemas}
           zodSchemas={zod.schemas}
           dataReturnType={options.client.dataReturnType}
+          paramsCasing={options.paramsCasing}
           paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
           parser={options.parser}
@@ -112,6 +114,7 @@ export const infiniteQueryGenerator = createReactGenerator<PluginVueQuery>({
               queryKeyName={queryKey.name}
               typeSchemas={type.schemas}
               paramsType={options.paramsType}
+              paramsCasing={options.paramsCasing}
               pathParamsType={options.pathParamsType}
               dataReturnType={options.client.dataReturnType}
               cursorParam={options.infinite.cursorParam}
@@ -128,6 +131,7 @@ export const infiniteQueryGenerator = createReactGenerator<PluginVueQuery>({
               name={query.name}
               queryOptionsName={queryOptions.name}
               typeSchemas={type.schemas}
+              paramsCasing={options.paramsCasing}
               paramsType={options.paramsType}
               pathParamsType={options.pathParamsType}
               operation={operation}

package/src/generators/mutationGenerator.tsx

@@ -80,6 +80,7 @@ export const mutationGenerator = createReactGenerator<PluginVueQuery>({
           typeName={mutationKey.typeName}
           operation={operation}
           pathParamsType={options.pathParamsType}
+          paramsCasing={options.paramsCasing}
           typeSchemas={type.schemas}
           transformer={options.mutationKey}
         />
@@ -92,6 +93,7 @@ export const mutationGenerator = createReactGenerator<PluginVueQuery>({
           typeSchemas={type.schemas}
           zodSchemas={zod.schemas}
           dataReturnType={options.client.dataReturnType}
+          paramsCasing={options.paramsCasing}
           paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
           parser={options.parser}
@@ -106,6 +108,7 @@ export const mutationGenerator = createReactGenerator<PluginVueQuery>({
               typeName={mutation.typeName}
               typeSchemas={type.schemas}
               operation={operation}
+              paramsCasing={options.paramsCasing}
               dataReturnType={options.client.dataReturnType}
               paramsType={options.paramsType}
               pathParamsType={options.pathParamsType}

package/src/generators/queryGenerator.tsx

@@ -84,6 +84,7 @@ export const queryGenerator = createReactGenerator<PluginVueQuery>({
           name={queryKey.name}
           typeName={queryKey.typeName}
           operation={operation}
+          paramsCasing={options.paramsCasing}
           pathParamsType={options.pathParamsType}
           typeSchemas={type.schemas}
           transformer={options.queryKey}
@@ -97,6 +98,7 @@ export const queryGenerator = createReactGenerator<PluginVueQuery>({
           typeSchemas={type.schemas}
           zodSchemas={zod.schemas}
           dataReturnType={options.client.dataReturnType}
+          paramsCasing={options.paramsCasing}
           paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
           parser={options.parser}
@@ -106,6 +108,7 @@ export const queryGenerator = createReactGenerator<PluginVueQuery>({
           name={queryOptions.name}
           clientName={client.name}
           queryKeyName={queryKey.name}
+          paramsCasing={options.paramsCasing}
           typeSchemas={type.schemas}
           paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
@@ -118,6 +121,7 @@ export const queryGenerator = createReactGenerator<PluginVueQuery>({
               name={query.name}
               queryOptionsName={queryOptions.name}
               typeSchemas={type.schemas}
+              paramsCasing={options.paramsCasing}
               paramsType={options.paramsType}
               pathParamsType={options.pathParamsType}
               operation={operation}

package/src/plugin.ts

@@ -29,6 +29,7 @@ export const pluginVueQuery = createPlugin<PluginVueQuery>((options) => {
     pathParamsType = 'inline',
     mutation = {},
     query = {},
+    paramsCasing,
     mutationKey = MutationKey.getTransformer,
     queryKey = QueryKey.getTransformer,
     generators = [queryGenerator, infiniteQueryGenerator, mutationGenerator].filter(Boolean),
@@ -70,6 +71,7 @@ export const pluginVueQuery = createPlugin<PluginVueQuery>((options) => {
       paramsType,
       pathParamsType: paramsType === 'object' ? 'object' : pathParamsType,
       parser,
+      paramsCasing,
       group,
     },
     pre: [pluginOasName, pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),

package/src/types.ts

@@ -8,6 +8,7 @@ import type { PluginReactQuery } from '@kubb/plugin-react-query'
 type TransformerProps = {
   operation: Operation
   schemas: OperationSchemas
+  casing: 'camelcase' | undefined
 }
 
 export type Transformer = (props: TransformerProps) => unknown[]
@@ -95,6 +96,11 @@ export type Options = {
    * 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' will use camelcase for the params names
+   */
+  paramsCasing?: 'camelcase'
   /**
    * How to pass your params
    * - 'object' will return the params and pathParams as an object.
@@ -145,6 +151,7 @@ type ResolvedOptions = {
   group: Options['group']
   client: Required<Omit<NonNullable<PluginReactQuery['options']['client']>, 'baseURL'>> & { baseURL?: string }
   parser: Required<NonNullable<Options['parser']>>
+  paramsCasing: Options['paramsCasing']
   paramsType: NonNullable<Options['paramsType']>
   pathParamsType: NonNullable<Options['pathParamsType']>
   /**