nuxt-openapi-hyperfetch 0.3.0-beta → 0.3.1-beta

package/src/generators/use-async-data/templates.ts

@@ -136,17 +136,18 @@ function generateFunctionBody(
 ): string {
   const hasParams = !!method.requestType;
   const paramsArg = hasParams ? `params: ${method.requestType}` : '';
+  const responseType = method.responseType !== 'void' ? method.responseType : 'void';
 
   // Determine the options type based on isRaw
   const optionsType = isRaw
-    ? `ApiAsyncDataRawOptions<${method.responseType}>`
-    : `ApiAsyncDataOptions<${method.responseType}>`;
-  const optionsArg = `options?: ${optionsType}`;
+    ? `ApiAsyncDataRawOptions<${responseType}, DataT, PickT>`
+    : `ApiAsyncDataOptions<${responseType}, DataT, PickT>`;
+  const optionsDefaultType = isRaw
+    ? `ApiAsyncDataRawOptions<${responseType}, DataT, PickT>`
+    : `ApiAsyncDataOptions<${responseType}, DataT, PickT>`;
+  const optionsArg = `options?: Options`;
   const args = hasParams ? `${paramsArg}, ${optionsArg}` : optionsArg;
 
-  // Determine the response type generic
-  const responseTypeGeneric = method.responseType !== 'void' ? `<${method.responseType}>` : '';
-
   // Generate unique key for useAsyncData
   const composableName =
     isRaw && method.rawMethodName
@@ -162,6 +163,12 @@ function generateFunctionBody(
 
   // Choose the correct wrapper function
   const wrapperFunction = isRaw ? 'useApiAsyncDataRaw' : 'useApiAsyncData';
+  const wrapperCall = isRaw
+    ? `${wrapperFunction}<${responseType}, DataT, PickT, Options>`
+    : `${wrapperFunction}<${responseType}, Options>`;
+  const returnType = isRaw
+    ? `ReturnType<typeof ${wrapperFunction}<${responseType}, DataT, PickT, Options>>`
+    : `ReturnType<typeof ${wrapperFunction}<${responseType}, Options>>`;
 
   const pInit = hasParams ? `\n  const p = shallowRef(params)` : '';
 
@@ -169,11 +176,19 @@ function generateFunctionBody(
     ? `  const _hasKey = typeof args[0] === 'string'\n  const params = _hasKey ? args[1] : args[0]\n  const options = _hasKey ? { cacheKey: args[0], ...args[2] } : args[1]`
     : `  const _hasKey = typeof args[0] === 'string'\n  const options = _hasKey ? { cacheKey: args[0], ...args[1] } : args[0]`;
 
-  return `${description}export function ${composableName}(key: string, ${args})
-export function ${composableName}(${args})
+  return `${description}export function ${composableName}<
+  DataT = ${responseType},
+  PickT extends ReadonlyArray<string> | undefined = undefined,
+  Options extends ${optionsType} = ${optionsDefaultType}
+>(key: string, ${args}): ${returnType}
+export function ${composableName}<
+  DataT = ${responseType},
+  PickT extends ReadonlyArray<string> | undefined = undefined,
+  Options extends ${optionsType} = ${optionsDefaultType}
+>(${args}): ${returnType}
 export function ${composableName}(...args: any[]) {
 ${argsExtraction}${pInit}
-  return ${wrapperFunction}${responseTypeGeneric}(${key}, ${url}, ${fetchOptions})
+  return ${wrapperCall}(${key}, ${url}, ${fetchOptions})
 }`;
 }
 

package/src/generators/use-fetch/runtime/useApiRequest.ts

@@ -37,12 +37,39 @@ type MaybeTransformed<T, Options> = Options extends { transform: (...args: any)
     ? any // With nested paths, type inference is complex, so we use any
     : T;
 
+type PickInput = ReadonlyArray<string> | undefined;
+
+type HasNestedPath<K extends ReadonlyArray<string>> =
+  Extract<K[number], `${string}.${string}`> extends never ? false : true;
+
+type PickedData<T, K extends PickInput> = K extends ReadonlyArray<string>
+  ? HasNestedPath<K> extends true
+    ? any
+    : Pick<T, Extract<K[number], keyof T>>
+  : T;
+
+type InferPick<Options> = Options extends { pick: infer K extends ReadonlyArray<string> }
+  ? K
+  : undefined;
+
+type InferData<T, Options> = Options extends { transform: (...args: any) => infer R }
+  ? R
+  : PickedData<T, InferPick<Options>>;
+
 /**
  * Options for useFetch API requests with lifecycle callbacks.
  * Extends all native Nuxt useFetch options plus our custom callbacks, transform, and pick.
  * Native options like baseURL, method, body, headers, query, lazy, server, immediate, etc. are all available.
  */
-export type ApiRequestOptions<T = any> = BaseApiRequestOptions<T> & Omit<UseFetchOptions<T>, 'transform' | 'pick'>;
+export type ApiRequestOptions<
+  T = any,
+  DataT = T,
+  PickT extends PickInput = undefined,
+> = Omit<BaseApiRequestOptions<T>, 'transform' | 'pick'> &
+  Omit<UseFetchOptions<T, DataT>, 'transform' | 'pick'> & {
+    pick?: PickT;
+    transform?: (data: PickedData<T, PickT>) => DataT;
+  };
 
 /**
  * Enhanced useFetch wrapper with lifecycle callbacks and request interception
@@ -80,7 +107,10 @@ export type ApiRequestOptions<T = any> = BaseApiRequestOptions<T> & Omit<UseFetc
  * });
  * ```
  */
-export function useApiRequest<T = any, Options extends ApiRequestOptions<T> = ApiRequestOptions<T>>(
+export function useApiRequest<
+  T = any,
+  Options extends ApiRequestOptions<T, any, any> = ApiRequestOptions<T>,
+>(
   url: string | (() => string),
   options?: Options
 ) {
@@ -224,10 +254,10 @@ export function useApiRequest<T = any, Options extends ApiRequestOptions<T> = Ap
   }
 
   // Make the actual request using Nuxt's useFetch
-  const result = useFetch<T>(url, modifiedOptions);
+  const result = useFetch<T>(url, modifiedOptions as UseFetchOptions<T, InferData<T, Options>>);
 
   // Create a ref for transformed data
-  type TransformedType = MaybeTransformed<T, Options>;
+  type TransformedType = InferData<T, Options>;
   const transformedData = ref<TransformedType | null>(null);
 
   // Track if callbacks have been executed to avoid duplicates

package/src/generators/use-fetch/templates.ts

@@ -116,12 +116,11 @@ function generateImports(method: MethodInfo, apiImportPath: string): string {
 function generateFunctionBody(method: MethodInfo, options?: GenerateOptions): string {
   const hasParams = !!method.requestType;
   const paramsArg = hasParams ? `params: ${method.requestType}` : '';
-  const optionsType = `ApiRequestOptions<${method.responseType}>`;
-  const optionsArg = `options?: ${optionsType}`;
+  const responseType = method.responseType !== 'void' ? method.responseType : 'void';
+  const optionsType = `ApiRequestOptions<${responseType}, DataT, PickT>`;
+  const optionsArg = `options?: Options`;
   const args = hasParams ? `${paramsArg}, ${optionsArg}` : optionsArg;
 
-  const responseTypeGeneric = method.responseType !== 'void' ? `<${method.responseType}>` : '';
-
   const url = generateUrl(method);
   const fetchOptions = generateFetchOptions(method, options);
 
@@ -129,8 +128,12 @@ function generateFunctionBody(method: MethodInfo, options?: GenerateOptions): st
 
   const pInit = hasParams ? `\n  const p = shallowRef(params)` : '';
 
-  return `${description}export const ${method.composableName} = (${args}) => {${pInit}
-  return useApiRequest${responseTypeGeneric}(${url}, ${fetchOptions})
+  return `${description}export const ${method.composableName} = <
+  DataT = ${responseType},
+  PickT extends ReadonlyArray<string> | undefined = undefined,
+  Options extends ${optionsType} = ApiRequestOptions<${responseType}, DataT, PickT>
+>(${args}) => {${pInit}
+  return useApiRequest<${responseType}, Options>(${url}, ${fetchOptions})
 }`;
 }