refactor: extract resolveOptions/resolveQueryFn helpers for skipToken

Author: nmokkenstorm

packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/@tanstack/angular-query-experimental.gen.ts

@@ -39,19 +39,23 @@ const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions
     return [params];
 };
 
+const resolveOptions = <T>(options: T | typeof skipToken) => options === skipToken ? undefined : options;
+
+const resolveQueryFn = <T>(options: T | typeof skipToken, queryFn: T) => options === skipToken ? skipToken : queryFn;
+
 export const getFooQueryKey = (options?: Options<GetFooData>) => createQueryKey('getFoo', options);
 
 export const getFooOptions = (options?: Options<GetFooData> | typeof skipToken) => queryOptions<GetFooResponse, DefaultError, GetFooResponse, ReturnType<typeof getFooQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await FooBazService.getFoo({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: getFooQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: getFooQueryKey(resolveOptions(options))
 });
 
 export const fooPostMutation = (options?: Partial<Options<FooPostData>>): MutationOptions<FooPostResponse, DefaultError, Options<FooPostData>> => {
@@ -85,16 +89,16 @@ export const fooPutMutation = (options?: Partial<Options<FooPutData>>): Mutation
 export const getFooBarQueryKey = (options?: Options<GetFooBarData>) => createQueryKey('getFooBar', options);
 
 export const getFooBarOptions = (options?: Options<GetFooBarData> | typeof skipToken) => queryOptions<GetFooBarResponse, DefaultError, GetFooBarResponse, ReturnType<typeof getFooBarQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await BarBazService.getFooBar({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: getFooBarQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: getFooBarQueryKey(resolveOptions(options))
 });
 
 export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): MutationOptions<FooBarPostResponse, DefaultError, Options<FooBarPostData>> => {

packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/@tanstack/angular-query-experimental.gen.ts

@@ -40,19 +40,23 @@ const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions
     return [params];
 };
 
+const resolveOptions = <T>(options: T | typeof skipToken) => options === skipToken ? undefined : options;
+
+const resolveQueryFn = <T>(options: T | typeof skipToken, queryFn: T) => options === skipToken ? skipToken : queryFn;
+
 export const serviceWithEmptyTagQueryKey = (options?: Options<ServiceWithEmptyTagData>) => createQueryKey('serviceWithEmptyTag', options);
 
 export const serviceWithEmptyTagOptions = (options?: Options<ServiceWithEmptyTagData> | typeof skipToken) => queryOptions<unknown, AxiosError<DefaultError>, unknown, ReturnType<typeof serviceWithEmptyTagQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await serviceWithEmptyTag({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: serviceWithEmptyTagQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: serviceWithEmptyTagQueryKey(resolveOptions(options))
 });
 
 export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<PatchApiVbyApiVersionNoTagData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PatchApiVbyApiVersionNoTagData>> => {
@@ -100,16 +104,16 @@ export const deleteCallWithoutParametersAndResponseMutation = (options?: Partial
 export const getCallWithoutParametersAndResponseQueryKey = (options?: Options<GetCallWithoutParametersAndResponseData>) => createQueryKey('getCallWithoutParametersAndResponse', options);
 
 export const getCallWithoutParametersAndResponseOptions = (options?: Options<GetCallWithoutParametersAndResponseData> | typeof skipToken) => queryOptions<unknown, AxiosError<DefaultError>, unknown, ReturnType<typeof getCallWithoutParametersAndResponseQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await getCallWithoutParametersAndResponse({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: getCallWithoutParametersAndResponseQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: getCallWithoutParametersAndResponseQueryKey(resolveOptions(options))
 });
 
 export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PatchCallWithoutParametersAndResponseData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<PatchCallWithoutParametersAndResponseData>> => {
@@ -199,16 +203,16 @@ export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<Ca
 export const callWithDefaultParametersQueryKey = (options: Options<CallWithDefaultParametersData>) => createQueryKey('callWithDefaultParameters', options);
 
 export const callWithDefaultParametersOptions = (options: Options<CallWithDefaultParametersData> | typeof skipToken) => queryOptions<unknown, AxiosError<DefaultError>, unknown, ReturnType<typeof callWithDefaultParametersQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await callWithDefaultParameters({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: callWithDefaultParametersQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: callWithDefaultParametersQueryKey(resolveOptions(options))
 });
 
 export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithDefaultOptionalParametersData>> => {
@@ -256,16 +260,16 @@ export const duplicateNameMutation = (options?: Partial<Options<DuplicateNameDat
 export const duplicateName2QueryKey = (options?: Options<DuplicateName2Data>) => createQueryKey('duplicateName2', options);
 
 export const duplicateName2Options = (options?: Options<DuplicateName2Data> | typeof skipToken) => queryOptions<unknown, AxiosError<DefaultError>, unknown, ReturnType<typeof duplicateName2QueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await duplicateName2({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: duplicateName2QueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: duplicateName2QueryKey(resolveOptions(options))
 });
 
 export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<DuplicateName3Data>> => {
@@ -299,76 +303,76 @@ export const duplicateName4Mutation = (options?: Partial<Options<DuplicateName4D
 export const callWithNoContentResponseQueryKey = (options?: Options<CallWithNoContentResponseData>) => createQueryKey('callWithNoContentResponse', options);
 
 export const callWithNoContentResponseOptions = (options?: Options<CallWithNoContentResponseData> | typeof skipToken) => queryOptions<unknown, AxiosError<DefaultError>, unknown, ReturnType<typeof callWithNoContentResponseQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await callWithNoContentResponse({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: callWithNoContentResponseQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: callWithNoContentResponseQueryKey(resolveOptions(options))
 });
 
 export const callWithResponseAndNoContentResponseQueryKey = (options?: Options<CallWithResponseAndNoContentResponseData>) => createQueryKey('callWithResponseAndNoContentResponse', options);
 
 export const callWithResponseAndNoContentResponseOptions = (options?: Options<CallWithResponseAndNoContentResponseData> | typeof skipToken) => queryOptions<CallWithResponseAndNoContentResponseResponse, AxiosError<DefaultError>, CallWithResponseAndNoContentResponseResponse, ReturnType<typeof callWithResponseAndNoContentResponseQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await callWithResponseAndNoContentResponse({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: callWithResponseAndNoContentResponseQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: callWithResponseAndNoContentResponseQueryKey(resolveOptions(options))
 });
 
 export const dummyAQueryKey = (options?: Options<DummyAData>) => createQueryKey('dummyA', options);
 
 export const dummyAOptions = (options?: Options<DummyAData> | typeof skipToken) => queryOptions<unknown, AxiosError<DefaultError>, unknown, ReturnType<typeof dummyAQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await dummyA({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: dummyAQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: dummyAQueryKey(resolveOptions(options))
 });
 
 export const dummyBQueryKey = (options?: Options<DummyBData>) => createQueryKey('dummyB', options);
 
 export const dummyBOptions = (options?: Options<DummyBData> | typeof skipToken) => queryOptions<unknown, AxiosError<DefaultError>, unknown, ReturnType<typeof dummyBQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await dummyB({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: dummyBQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: dummyBQueryKey(resolveOptions(options))
 });
 
 export const callWithResponseQueryKey = (options?: Options<CallWithResponseData>) => createQueryKey('callWithResponse', options);
 
 export const callWithResponseOptions = (options?: Options<CallWithResponseData> | typeof skipToken) => queryOptions<CallWithResponseResponse, AxiosError<DefaultError>, CallWithResponseResponse, ReturnType<typeof callWithResponseQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await callWithResponse({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: callWithResponseQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: callWithResponseQueryKey(resolveOptions(options))
 });
 
 export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): MutationOptions<CallWithDuplicateResponsesResponse, AxiosError<CallWithDuplicateResponsesError>, Options<CallWithDuplicateResponsesData>> => {
@@ -402,46 +406,46 @@ export const callWithResponsesMutation = (options?: Partial<Options<CallWithResp
 export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => createQueryKey('collectionFormat', options);
 
 export const collectionFormatOptions = (options: Options<CollectionFormatData> | typeof skipToken) => queryOptions<unknown, AxiosError<DefaultError>, unknown, ReturnType<typeof collectionFormatQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await collectionFormat({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: collectionFormatQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: collectionFormatQueryKey(resolveOptions(options))
 });
 
 export const typesQueryKey = (options: Options<TypesData>) => createQueryKey('types', options);
 
 export const typesOptions = (options: Options<TypesData> | typeof skipToken) => queryOptions<TypesResponse, AxiosError<DefaultError>, TypesResponse, ReturnType<typeof typesQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await types({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: typesQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: typesQueryKey(resolveOptions(options))
 });
 
 export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => createQueryKey('complexTypes', options);
 
 export const complexTypesOptions = (options: Options<ComplexTypesData> | typeof skipToken) => queryOptions<ComplexTypesResponse, AxiosError<DefaultError>, ComplexTypesResponse, ReturnType<typeof complexTypesQueryKey>>({
-    queryFn: options === skipToken ? skipToken : async ({ queryKey, signal }) => {
+    queryFn: resolveQueryFn(options, async ({ queryKey, signal }) => {
         const { data } = await complexTypes({
             ...options,
             ...queryKey[0],
             signal,
             throwOnError: true
         });
         return data;
-    },
-    queryKey: complexTypesQueryKey(options === skipToken ? undefined as never : options)
+    }),
+    queryKey: complexTypesQueryKey(resolveOptions(options))
 });
 
 export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): MutationOptions<unknown, AxiosError<DefaultError>, Options<CallWithResultFromHeaderData>> => {