@kubb/plugin-react-query 3.0.0-alpha.0

package/src/OperationGenerator.tsx

@@ -0,0 +1,86 @@
+import { OperationGenerator as Generator } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { App, createRoot } from '@kubb/react'
+
+import { Mutation } from './components/Mutation.tsx'
+import { Operations } from './components/Operations.tsx'
+import { Query } from './components/Query.tsx'
+import { QueryKey } from './components/QueryKey.tsx'
+import { QueryOptions } from './components/QueryOptions.tsx'
+
+import type { Operation } from '@kubb/oas'
+import type { OperationMethodResult } from '@kubb/plugin-oas'
+import { QueryImports } from './components/QueryImports.tsx'
+import type { FileMeta, PluginReactQuery } from './types.ts'
+
+export class OperationGenerator extends Generator<PluginReactQuery['resolvedOptions'], PluginReactQuery, FileMeta> {
+  async all(operations: Operation[]): OperationMethodResult<FileMeta> {
+    const { pluginManager, oas, plugin, mode } = this.context
+
+    const root = createRoot({
+      logger: pluginManager.logger,
+    })
+
+    const templates = {
+      mutation: Mutation.templates,
+      query: Query.templates,
+      queryOptions: QueryOptions.templates,
+      queryKey: QueryKey.templates,
+      queryImports: QueryImports.templates,
+      operations: Operations.templates,
+      ...this.options.templates,
+    }
+
+    root.render(
+      <App pluginManager={pluginManager} plugin={plugin} mode={mode}>
+        <Oas oas={oas} operations={operations} generator={this}>
+          {templates.operations && <Operations.File templates={templates.operations} />}
+        </Oas>
+      </App>,
+    )
+
+    return root.files
+  }
+
+  async operation(operation: Operation, options: PluginReactQuery['resolvedOptions']): OperationMethodResult<FileMeta> {
+    const { oas, pluginManager, plugin, mode } = this.context
+
+    const root = createRoot({
+      logger: pluginManager.logger,
+    })
+
+    const templates = {
+      mutation: Mutation.templates,
+      query: Query.templates,
+      queryOptions: QueryOptions.templates,
+      queryKey: QueryKey.templates,
+      queryImports: QueryImports.templates,
+      ...options.templates,
+    }
+
+    const isQuery = typeof options.query === 'boolean' ? true : options.query?.methods.some((method) => operation.method === method)
+    const isMutate = !isQuery && options.mutate && options.mutate.methods.some((method) => operation.method === method)
+
+    root.render(
+      <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
+        <Oas oas={oas} operations={[operation]} generator={this}>
+          <Oas.Operation operation={operation}>
+            {isMutate && templates?.mutation && <Mutation.File templates={templates.mutation} />}
+            {isQuery && templates?.query && templates.queryKey && templates.queryOptions && templates.queryImports && (
+              <Query.File
+                templates={{
+                  query: templates.query,
+                  queryKey: templates.queryKey,
+                  queryOptions: templates.queryOptions,
+                  queryImports: templates.queryImports,
+                }}
+              />
+            )}
+          </Oas.Operation>
+        </Oas>
+      </App>,
+    )
+
+    return root.files
+  }
+}

package/src/__snapshots__/mutateAsQuery/updatePetWithForm.ts

@@ -0,0 +1,64 @@
+import client from "@kubb/plugin-client/client";
+import { useQuery } from "@tanstack/react-query";
+import type { UseBaseQueryOptions, UseQueryResult, QueryKey, WithRequired } from "@tanstack/react-query";
+
+ type UpdatePetWithFormClient = typeof client<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, UpdatePetWithFormMutationRequest>;
+type UpdatePetWithForm = {
+    data: UpdatePetWithFormMutationResponse;
+    error: UpdatePetWithForm405;
+    request: UpdatePetWithFormMutationRequest;
+    pathParams: UpdatePetWithFormPathParams;
+    queryParams: UpdatePetWithFormQueryParams;
+    headerParams: never;
+    response: UpdatePetWithFormMutationResponse;
+    client: {
+        parameters: Partial<Parameters<UpdatePetWithFormClient>[0]>;
+        return: Awaited<ReturnType<UpdatePetWithFormClient>>;
+    };
+};
+export const UpdatePetWithFormQueryKey = ({ petId }: {
+    petId: UpdatePetWithFormPathParams["petId"];
+}, params?: UpdatePetWithForm["queryParams"], data?: UpdatePetWithForm["request"]) => [{ url: "/pet/:petId", params: { petId: petId } }, ...(params ? [params] : []), ...(data ? [data] : [])] as const;
+export type UpdatePetWithFormQueryKey = ReturnType<typeof UpdatePetWithFormQueryKey>;
+export function UpdatePetWithFormQueryOptions<TData = UpdatePetWithForm["response"], TQueryData = UpdatePetWithForm["response"]>({ petId }: {
+    petId: UpdatePetWithFormPathParams["petId"];
+}, params?: UpdatePetWithForm["queryParams"], data?: UpdatePetWithForm["request"], options: UpdatePetWithForm["client"]["parameters"] = {}): WithRequired<UseBaseQueryOptions<UpdatePetWithForm["response"], UpdatePetWithForm["error"], TData, TQueryData>, "queryKey"> {
+    const queryKey = UpdatePetWithFormQueryKey({ petId }, params, data);
+    return {
+        queryKey,
+        queryFn: async () => {
+            const res = await client<UpdatePetWithForm["data"], UpdatePetWithForm["error"]>({
+                method: "post",
+                url: `/pet/${petId}`,
+                params,
+                data,
+                ...options
+            });
+            return res.data;
+        },
+    };
+}
+/**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+export function updatePetWithForm<TData = UpdatePetWithForm["response"], TQueryData = UpdatePetWithForm["response"], TQueryKey extends QueryKey = UpdatePetWithFormQueryKey>({ petId }: {
+    petId: UpdatePetWithFormPathParams["petId"];
+}, params?: UpdatePetWithForm["queryParams"], data?: UpdatePetWithForm["request"], options: {
+    query?: Partial<UseBaseQueryOptions<UpdatePetWithForm["response"], UpdatePetWithForm["error"], TData, TQueryData, TQueryKey>>;
+    client?: UpdatePetWithForm["client"]["parameters"];
+} = {}): UseQueryResult<TData, UpdatePetWithForm["error"]> & {
+    queryKey: TQueryKey;
+} {
+    const { query: queryOptions, client: clientOptions = {} } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? UpdatePetWithFormQueryKey({ petId }, params, data);
+    const query = useQuery<UpdatePetWithForm["data"], UpdatePetWithForm["error"], TData, any>({
+        ...UpdatePetWithFormQueryOptions<TData, TQueryData>({ petId }, params, data, clientOptions),
+        queryKey,
+        ...queryOptions
+    }) as UseQueryResult<TData, UpdatePetWithForm["error"]> & {
+        queryKey: TQueryKey;
+    };
+    query.queryKey = queryKey as TQueryKey;
+    return query;
+}

package/src/__snapshots__/pathParamsTypeInline/getPetById.ts

@@ -0,0 +1,57 @@
+import client from "@kubb/plugin-client/client";
+import { useQuery } from "@tanstack/react-query";
+import type { UseBaseQueryOptions, UseQueryResult, QueryKey, WithRequired } from "@tanstack/react-query";
+
+ type GetPetByIdClient = typeof client<GetPetByIdQueryResponse, GetPetById400 | GetPetById404, never>;
+type GetPetById = {
+    data: GetPetByIdQueryResponse;
+    error: GetPetById400 | GetPetById404;
+    request: never;
+    pathParams: GetPetByIdPathParams;
+    queryParams: never;
+    headerParams: never;
+    response: GetPetByIdQueryResponse;
+    client: {
+        parameters: Partial<Parameters<GetPetByIdClient>[0]>;
+        return: Awaited<ReturnType<GetPetByIdClient>>;
+    };
+};
+export const GetPetByIdQueryKey = (petId: GetPetByIdPathParams["petId"]) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
+export type GetPetByIdQueryKey = ReturnType<typeof GetPetByIdQueryKey>;
+export function GetPetByIdQueryOptions<TData = GetPetById["response"], TQueryData = GetPetById["response"]>(petId: GetPetByIdPathParams["petId"], options: GetPetById["client"]["parameters"] = {}): WithRequired<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData>, "queryKey"> {
+    const queryKey = GetPetByIdQueryKey(petId);
+    return {
+        queryKey,
+        queryFn: async () => {
+            const res = await client<GetPetById["data"], GetPetById["error"]>({
+                method: "get",
+                url: `/pet/${petId}`,
+                ...options
+            });
+            return res.data;
+        },
+    };
+}
+/**
+ * @description Returns a single pet
+ * @summary Find pet by ID
+ * @link /pet/:petId
+ */
+export function getPetById<TData = GetPetById["response"], TQueryData = GetPetById["response"], TQueryKey extends QueryKey = GetPetByIdQueryKey>(petId: GetPetByIdPathParams["petId"], options: {
+    query?: Partial<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData, TQueryKey>>;
+    client?: GetPetById["client"]["parameters"];
+} = {}): UseQueryResult<TData, GetPetById["error"]> & {
+    queryKey: TQueryKey;
+} {
+    const { query: queryOptions, client: clientOptions = {} } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? GetPetByIdQueryKey(petId);
+    const query = useQuery<GetPetById["data"], GetPetById["error"], TData, any>({
+        ...GetPetByIdQueryOptions<TData, TQueryData>(petId, clientOptions),
+        queryKey,
+        ...queryOptions
+    }) as UseQueryResult<TData, GetPetById["error"]> & {
+        queryKey: TQueryKey;
+    };
+    query.queryKey = queryKey as TQueryKey;
+    return query;
+}

package/src/__snapshots__/pathParamsTypeObject/getPetById.ts

@@ -0,0 +1,63 @@
+import client from "@kubb/plugin-client/client";
+import { useQuery } from "@tanstack/react-query";
+import type { UseBaseQueryOptions, UseQueryResult, QueryKey, WithRequired } from "@tanstack/react-query";
+
+ type GetPetByIdClient = typeof client<GetPetByIdQueryResponse, GetPetById400 | GetPetById404, never>;
+type GetPetById = {
+    data: GetPetByIdQueryResponse;
+    error: GetPetById400 | GetPetById404;
+    request: never;
+    pathParams: GetPetByIdPathParams;
+    queryParams: never;
+    headerParams: never;
+    response: GetPetByIdQueryResponse;
+    client: {
+        parameters: Partial<Parameters<GetPetByIdClient>[0]>;
+        return: Awaited<ReturnType<GetPetByIdClient>>;
+    };
+};
+export const GetPetByIdQueryKey = ({ petId }: {
+    petId: GetPetByIdPathParams["petId"];
+}) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
+export type GetPetByIdQueryKey = ReturnType<typeof GetPetByIdQueryKey>;
+export function GetPetByIdQueryOptions<TData = GetPetById["response"], TQueryData = GetPetById["response"]>({ petId }: {
+    petId: GetPetByIdPathParams["petId"];
+}, options: GetPetById["client"]["parameters"] = {}): WithRequired<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData>, "queryKey"> {
+    const queryKey = GetPetByIdQueryKey({ petId });
+    return {
+        queryKey,
+        queryFn: async () => {
+            const res = await client<GetPetById["data"], GetPetById["error"]>({
+                method: "get",
+                url: `/pet/${petId}`,
+                ...options
+            });
+            return res.data;
+        },
+    };
+}
+/**
+ * @description Returns a single pet
+ * @summary Find pet by ID
+ * @link /pet/:petId
+ */
+export function getPetById<TData = GetPetById["response"], TQueryData = GetPetById["response"], TQueryKey extends QueryKey = GetPetByIdQueryKey>({ petId }: {
+    petId: GetPetByIdPathParams["petId"];
+}, options: {
+    query?: Partial<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData, TQueryKey>>;
+    client?: GetPetById["client"]["parameters"];
+} = {}): UseQueryResult<TData, GetPetById["error"]> & {
+    queryKey: TQueryKey;
+} {
+    const { query: queryOptions, client: clientOptions = {} } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? GetPetByIdQueryKey({ petId });
+    const query = useQuery<GetPetById["data"], GetPetById["error"], TData, any>({
+        ...GetPetByIdQueryOptions<TData, TQueryData>({ petId }, clientOptions),
+        queryKey,
+        ...queryOptions
+    }) as UseQueryResult<TData, GetPetById["error"]> & {
+        queryKey: TQueryKey;
+    };
+    query.queryKey = queryKey as TQueryKey;
+    return query;
+}

package/src/__snapshots__/queryOptions/getPetById.ts

@@ -0,0 +1,37 @@
+import client from "@kubb/plugin-client/client";
+import type { UseBaseQueryOptions, QueryKey, WithRequired } from "@tanstack/react-query";
+
+ type GetPetByIdClient = typeof client<GetPetByIdQueryResponse, GetPetById400 | GetPetById404, never>;
+type GetPetById = {
+    data: GetPetByIdQueryResponse;
+    error: GetPetById400 | GetPetById404;
+    request: never;
+    pathParams: GetPetByIdPathParams;
+    queryParams: never;
+    headerParams: never;
+    response: GetPetByIdQueryResponse;
+    client: {
+        parameters: Partial<Parameters<GetPetByIdClient>[0]>;
+        return: Awaited<ReturnType<GetPetByIdClient>>;
+    };
+};
+export const GetPetByIdQueryKey = ({ petId }: {
+    petId: GetPetByIdPathParams["petId"];
+}) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
+export type GetPetByIdQueryKey = ReturnType<typeof GetPetByIdQueryKey>;
+export function GetPetByIdQueryOptions<TData = GetPetById["response"], TQueryData = GetPetById["response"]>({ petId }: {
+    petId: GetPetByIdPathParams["petId"];
+}, options: GetPetById["client"]["parameters"] = {}): WithRequired<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData>, "queryKey"> {
+    const queryKey = GetPetByIdQueryKey({ petId });
+    return {
+        queryKey,
+        queryFn: async () => {
+            const res = await client<GetPetById["data"], GetPetById["error"]>({
+                method: "get",
+                url: `/pet/${petId}`,
+                ...options
+            });
+            return res.data;
+        },
+    };
+}

package/src/__snapshots__/queryWithoutQueryOptions/getPetById.ts

@@ -0,0 +1,47 @@
+import client from "@kubb/plugin-client/client";
+import { useQuery } from "@tanstack/react-query";
+import type { UseBaseQueryOptions, UseQueryResult, QueryKey } from "@tanstack/react-query";
+
+ type GetPetByIdClient = typeof client<GetPetByIdQueryResponse, GetPetById400 | GetPetById404, never>;
+type GetPetById = {
+    data: GetPetByIdQueryResponse;
+    error: GetPetById400 | GetPetById404;
+    request: never;
+    pathParams: GetPetByIdPathParams;
+    queryParams: never;
+    headerParams: never;
+    response: GetPetByIdQueryResponse;
+    client: {
+        parameters: Partial<Parameters<GetPetByIdClient>[0]>;
+        return: Awaited<ReturnType<GetPetByIdClient>>;
+    };
+};
+export const GetPetByIdQueryKey = ({ petId }: {
+    petId: GetPetByIdPathParams["petId"];
+}) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
+export type GetPetByIdQueryKey = ReturnType<typeof GetPetByIdQueryKey>;
+/**
+ * @description Returns a single pet
+ * @summary Find pet by ID
+ * @link /pet/:petId
+ */
+export function getPetById<TData = GetPetById["response"], TQueryData = GetPetById["response"], TQueryKey extends QueryKey = GetPetByIdQueryKey>({ petId }: {
+    petId: GetPetByIdPathParams["petId"];
+}, options: {
+    query?: Partial<UseBaseQueryOptions<GetPetById["response"], GetPetById["error"], TData, TQueryData, TQueryKey>>;
+    client?: GetPetById["client"]["parameters"];
+} = {}): UseQueryResult<TData, GetPetById["error"]> & {
+    queryKey: TQueryKey;
+} {
+    const { query: queryOptions, client: clientOptions = {} } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? GetPetByIdQueryKey({ petId });
+    const query = useQuery<GetPetById["data"], GetPetById["error"], TData, any>({
+        ...GetPetByIdQueryOptions<TData, TQueryData>({ petId }, clientOptions),
+        queryKey,
+        ...queryOptions
+    }) as UseQueryResult<TData, GetPetById["error"]> & {
+        queryKey: TQueryKey;
+    };
+    query.queryKey = queryKey as TQueryKey;
+    return query;
+}

package/src/__snapshots__/upload/UploadFile.ts

@@ -0,0 +1,67 @@
+import client from "@kubb/plugin-client/client";
+import { useQuery } from "@tanstack/react-query";
+import type { UseBaseQueryOptions, UseQueryResult, QueryKey, WithRequired } from "@tanstack/react-query";
+
+ type UploadFileClient = typeof client<UploadFileMutationResponse, UploadFile400, FormData>;
+type UploadFile = {
+    data: UploadFileMutationResponse;
+    error: UploadFile400;
+    request: FormData;
+    pathParams: never;
+    queryParams: never;
+    headerParams: never;
+    response: UploadFileMutationResponse;
+    client: {
+        parameters: Partial<Parameters<UploadFileClient>[0]>;
+        return: Awaited<ReturnType<UploadFileClient>>;
+    };
+};
+export const UploadFileQueryKey = (data: UploadFile["request"]) => [{ url: "/upload" }, ...(data ? [data] : [])] as const;
+export type UploadFileQueryKey = ReturnType<typeof UploadFileQueryKey>;
+export function UploadFileQueryOptions<TData = UploadFile["response"], TQueryData = UploadFile["response"]>(data: UploadFile["request"], options: UploadFile["client"]["parameters"] = {}): WithRequired<UseBaseQueryOptions<UploadFile["response"], UploadFile["error"], TData, TQueryData>, "queryKey"> {
+    const queryKey = UploadFileQueryKey(data);
+    return {
+        queryKey,
+        queryFn: async () => {
+            const formData = new FormData();
+            if (data) {
+                Object.keys(data).forEach((key) => {
+                    const value = data[key];
+                    if (typeof key === "string" && (typeof value === "string" || value instanceof Blob)) {
+                        formData.append(key, value);
+                    }
+                });
+            }
+            const res = await client<UploadFile["data"], UploadFile["error"]>({
+                method: "post",
+                url: `/upload`,
+                data: formData,
+                headers: { "Content-Type": "multipart/form-data", ...options.headers },
+                ...options
+            });
+            return res.data;
+        },
+    };
+}
+/**
+ * @description Upload file
+ * @link /upload
+ */
+export function UploadFile<TData = UploadFile["response"], TQueryData = UploadFile["response"], TQueryKey extends QueryKey = UploadFileQueryKey>(data: UploadFile["request"], options: {
+    query?: Partial<UseBaseQueryOptions<UploadFile["response"], UploadFile["error"], TData, TQueryData, TQueryKey>>;
+    client?: UploadFile["client"]["parameters"];
+} = {}): UseQueryResult<TData, UploadFile["error"]> & {
+    queryKey: TQueryKey;
+} {
+    const { query: queryOptions, client: clientOptions = {} } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? UploadFileQueryKey(data);
+    const query = useQuery<UploadFile["data"], UploadFile["error"], TData, any>({
+        ...UploadFileQueryOptions<TData, TQueryData>(data, clientOptions),
+        queryKey,
+        ...queryOptions
+    }) as UseQueryResult<TData, UploadFile["error"]> & {
+        queryKey: TQueryKey;
+    };
+    query.queryKey = queryKey as TQueryKey;
+    return query;
+}

package/src/__snapshots__/uploadMutation/UploadFile.ts

@@ -0,0 +1,44 @@
+import client from "@kubb/plugin-client/client";
+import type { UseBaseQueryOptions, QueryKey, WithRequired } from "@tanstack/react-query";
+
+ type UploadFileClient = typeof client<UploadFileMutationResponse, UploadFile400, FormData>;
+type UploadFile = {
+    data: UploadFileMutationResponse;
+    error: UploadFile400;
+    request: FormData;
+    pathParams: never;
+    queryParams: never;
+    headerParams: never;
+    response: UploadFileMutationResponse;
+    client: {
+        parameters: Partial<Parameters<UploadFileClient>[0]>;
+        return: Awaited<ReturnType<UploadFileClient>>;
+    };
+};
+export const UploadFileQueryKey = (data: UploadFile["request"]) => [{ url: "/upload" }, ...(data ? [data] : [])] as const;
+export type UploadFileQueryKey = ReturnType<typeof UploadFileQueryKey>;
+export function UploadFileQueryOptions<TData = UploadFile["response"], TQueryData = UploadFile["response"]>(data: UploadFile["request"], options: UploadFile["client"]["parameters"] = {}): WithRequired<UseBaseQueryOptions<UploadFile["response"], UploadFile["error"], TData, TQueryData>, "queryKey"> {
+    const queryKey = UploadFileQueryKey(data);
+    return {
+        queryKey,
+        queryFn: async () => {
+            const formData = new FormData();
+            if (data) {
+                Object.keys(data).forEach((key) => {
+                    const value = data[key];
+                    if (typeof key === "string" && (typeof value === "string" || value instanceof Blob)) {
+                        formData.append(key, value);
+                    }
+                });
+            }
+            const res = await client<UploadFile["data"], UploadFile["error"]>({
+                method: "post",
+                url: `/upload`,
+                data: formData,
+                headers: { "Content-Type": "multipart/form-data", ...options.headers },
+                ...options
+            });
+            return res.data;
+        },
+    };
+}

package/src/__snapshots__/variablesTypeMutate/deletePet.ts

@@ -0,0 +1,21 @@
+import client from "@kubb/plugin-client/client";
+import type { QueryKey } from "@tanstack/react-query";
+
+ type DeletePetClient = typeof client<DeletePetMutationResponse, DeletePet400, never>;
+type DeletePet = {
+    data: DeletePetMutationResponse;
+    error: DeletePet400;
+    request: never;
+    pathParams: DeletePetPathParams;
+    queryParams: never;
+    headerParams: DeletePetHeaderParams;
+    response: DeletePetMutationResponse;
+    client: {
+        parameters: Partial<Parameters<DeletePetClient>[0]>;
+        return: Awaited<ReturnType<DeletePetClient>>;
+    };
+};
+export const DeletePetQueryKey = ({ petId }: {
+    petId: DeletePetPathParams["petId"];
+}) => [{ url: "/pet/:petId", params: { petId: petId } }] as const;
+export type DeletePetQueryKey = ReturnType<typeof DeletePetQueryKey>;