@kubb/plugin-react-query 3.0.0-alpha.9 → 3.0.0-beta.2

package/dist/index-5kpkk-7M.d.ts

@@ -1,545 +0,0 @@
-import { URLPath } from '@kubb/core/utils';
-import { HttpMethod } from '@kubb/oas';
-import { ReactNode, ComponentType, ComponentProps } from 'react';
-import { PluginFactoryOptions, ResolveNameParams } from '@kubb/core';
-import * as KubbFile from '@kubb/fs/types';
-import { ResolvePathOptions, Exclude, Include, Override } from '@kubb/plugin-oas';
-
-type TemplateProps$4 = {
-    /**
-     * Name of the function
-     */
-    name: string;
-    /**
-     * Parameters/options/props that need to be used
-     */
-    params: string;
-    mutateParams: string;
-    /**
-     * Options for JSdocs
-     */
-    JSDoc?: {
-        comments: string[];
-    };
-    hook: {
-        name: string;
-        generics?: string;
-        children?: string;
-    };
-    client: {
-        generics: string;
-        method: HttpMethod;
-        path: URLPath;
-        withQueryParams: boolean;
-        withPathParams: boolean;
-        withData: boolean;
-        withHeaders: boolean;
-        contentType: string;
-    };
-    dataReturnType: NonNullable<PluginReactQuery['options']['dataReturnType']>;
-};
-declare function Template({ name, params, mutateParams, JSDoc, client, hook, dataReturnType }: TemplateProps$4): ReactNode;
-type RootTemplateProps = {
-    children?: React.ReactNode;
-};
-declare function RootTemplate({ children }: RootTemplateProps): JSX.Element;
-declare const defaultTemplates$1: {
-    readonly default: typeof Template;
-    readonly root: typeof RootTemplate;
-};
-type Templates$1 = Partial<typeof defaultTemplates$1>;
-type MutationProps = {
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    Template?: ComponentType<ComponentProps<typeof Template>>;
-};
-declare function Mutation({ Template }: MutationProps): ReactNode;
-declare namespace Mutation {
-    var File: ({ ...props }: FileProps$1) => ReactNode;
-    var templates: {
-        readonly default: typeof Template;
-        readonly root: typeof RootTemplate;
-    };
-}
-type FileProps$1 = {
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    templates?: Templates$1;
-};
-
-type TemplateProps$3 = {
-    /**
-     * Path to @tanstack-query
-     */
-    path: string;
-    /**
-     * Override the path of 'useQuery'
-     * @default 'path'
-     */
-    hookPath: string | undefined;
-    optionsType: string;
-    queryOptions: string | undefined;
-    resultType: string;
-    hookName: string;
-    isInfinite: boolean;
-};
-type FrameworkProps$3 = Partial<TemplateProps$3> & {
-    context: {
-        isInfinite: boolean;
-        isSuspense: boolean;
-    };
-};
-type Props$3 = {
-    hookPath: string | undefined;
-    isInfinite: boolean;
-    /**
-     * Only for React and v5
-     */
-    isSuspense: boolean;
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    Template?: React.ComponentType<FrameworkProps$3>;
-};
-declare function QueryImports({ hookPath, isInfinite, isSuspense, Template }: Props$3): ReactNode;
-declare namespace QueryImports {
-    var templates: {
-        readonly react: ({ context, hookPath, ...rest }: FrameworkProps$3) => ReactNode;
-        readonly solid: ({ context, hookPath, ...rest }: FrameworkProps$3) => ReactNode;
-        readonly svelte: ({ context, hookPath, ...rest }: FrameworkProps$3) => ReactNode;
-        readonly vue: ({ context, hookPath, ...rest }: FrameworkProps$3) => ReactNode;
-    };
-}
-
-type TemplateProps$2 = {
-    /**
-     * Name of the function
-     */
-    name: string;
-    /**
-     * TypeName of the function in PascalCase
-     */
-    typeName: string;
-    /**
-     * Parameters/options/props that need to be used
-     */
-    params: string;
-    /**
-     * Generics that needs to be added for TypeScript
-     */
-    generics?: string;
-    /**
-     * ReturnType(see async for adding Promise type)
-     */
-    returnType?: string;
-    /**
-     * Options for JSdocs
-     */
-    JSDoc?: {
-        comments: string[];
-    };
-    keys?: string;
-};
-type FrameworkProps$2 = TemplateProps$2 & {
-    context: {
-        factory: {
-            name: string;
-        };
-    };
-};
-type Props$2 = {
-    name: string;
-    typeName: string;
-    keysFn: (keys: unknown[]) => unknown[];
-    factory: {
-        name: string;
-    };
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    Template?: React.ComponentType<FrameworkProps$2>;
-};
-declare function QueryKey({ name, typeName, factory, keysFn, Template }: Props$2): ReactNode;
-declare namespace QueryKey {
-    var templates: {
-        readonly react: (props: FrameworkProps$2) => ReactNode;
-        readonly solid: (props: FrameworkProps$2) => ReactNode;
-        readonly svelte: (props: FrameworkProps$2) => ReactNode;
-        readonly vue: ({ context, ...rest }: FrameworkProps$2) => ReactNode;
-    };
-}
-
-type TemplateProps$1 = {
-    /**
-     * Name of the function
-     */
-    name: string;
-    /**
-     * Parameters/options/props that need to be used
-     */
-    params: string;
-    /**
-     * Generics that needs to be added for TypeScript
-     */
-    generics?: string;
-    /**
-     * ReturnType(see async for adding Promise type)
-     */
-    returnType?: string;
-    /**
-     * Options for JSdocs
-     */
-    JSDoc?: {
-        comments: string[];
-    };
-    hook: {
-        queryKey: string;
-        children?: string;
-    };
-    client: {
-        generics: string;
-        method: HttpMethod;
-        path: URLPath;
-        withQueryParams: boolean;
-        withPathParams: boolean;
-        withData: boolean;
-        withHeaders: boolean;
-        contentType: string;
-    };
-    infinite: Infinite | false;
-    dataReturnType: NonNullable<PluginReactQuery['options']['dataReturnType']>;
-    parser: string | undefined;
-};
-type FrameworkProps$1 = TemplateProps$1 & {
-    context: {
-        factory: {
-            name: string;
-        };
-        queryKey: string;
-    };
-};
-type Props$1 = {
-    infinite: Infinite | false;
-    suspense: Suspense | false;
-    factory: {
-        name: string;
-    };
-    resultType: string;
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    Template?: React.ComponentType<FrameworkProps$1>;
-    dataReturnType: NonNullable<PluginReactQuery['options']['dataReturnType']>;
-};
-declare function QueryOptions$1({ factory, infinite, suspense, resultType, dataReturnType, Template }: Props$1): ReactNode;
-declare namespace QueryOptions$1 {
-    var templates: {
-        readonly react: (props: FrameworkProps$1) => ReactNode;
-        readonly solid: (props: FrameworkProps$1) => ReactNode;
-        readonly svelte: (props: FrameworkProps$1) => ReactNode;
-        readonly vue: ({ client, context, ...rest }: FrameworkProps$1) => ReactNode;
-    };
-}
-
-type TemplateProps = {
-    /**
-     * Name of the function
-     */
-    name: string;
-    /**
-     * Parameters/options/props that need to be used
-     */
-    params: string;
-    /**
-     * Generics that needs to be added for TypeScript
-     */
-    generics?: string;
-    /**
-     * ReturnType(see async for adding Promise type)
-     */
-    returnType?: string;
-    /**
-     * Options for JSdocs
-     */
-    JSDoc?: {
-        comments: string[];
-    };
-    hook: {
-        name: string;
-        generics?: string;
-        queryKey: string;
-        queryOptions: string;
-    };
-    infinite: Infinite | false;
-};
-type FrameworkProps = TemplateProps & {
-    context: {
-        factory: {
-            name: string;
-        };
-        queryKey: string;
-    };
-};
-declare const defaultTemplates: {
-    readonly react: (props: FrameworkProps) => ReactNode;
-    readonly solid: (props: FrameworkProps) => ReactNode;
-    readonly svelte: (props: FrameworkProps) => ReactNode;
-    readonly vue: ({ context, hook, ...rest }: FrameworkProps) => ReactNode;
-};
-type Props = {
-    factory: {
-        name: string;
-    };
-    resultType: string;
-    hookName: string;
-    optionsType: string;
-    infinite: Infinite | false;
-    query: Query | false;
-    queryOptions: QueryOptions | false;
-    suspense: Suspense | false;
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    Template?: React.ComponentType<FrameworkProps>;
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    QueryKeyTemplate?: React.ComponentType<React.ComponentProps<typeof QueryKey.templates.react>>;
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    QueryOptionsTemplate?: React.ComponentType<React.ComponentProps<typeof QueryOptions$1.templates.react>>;
-};
-declare function Query$1({ factory, optionsType, hookName, resultType, Template, QueryKeyTemplate, QueryOptionsTemplate, ...props }: Props): ReactNode;
-declare namespace Query$1 {
-    var File: ({ templates }: FileProps) => ReactNode;
-    var templates: {
-        readonly react: (props: FrameworkProps) => ReactNode;
-        readonly solid: (props: FrameworkProps) => ReactNode;
-        readonly svelte: (props: FrameworkProps) => ReactNode;
-        readonly vue: ({ context, hook, ...rest }: FrameworkProps) => ReactNode;
-    };
-}
-type FileProps = {
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    templates?: {
-        query: typeof defaultTemplates;
-        queryKey: typeof QueryKey.templates;
-        queryOptions: typeof QueryOptions$1.templates;
-        queryImports: typeof QueryImports.templates;
-    };
-};
-
-type Templates = {
-    mutation?: typeof Mutation.templates | false;
-    query?: typeof Query$1.templates | false;
-    queryOptions?: typeof QueryOptions$1.templates | false;
-    queryKey?: typeof QueryKey.templates | false;
-};
-type Suspense = object;
-type Query = {
-    /**
-     * Customize the queryKey, here you can specify a suffix.
-     */
-    queryKey: (key: unknown[]) => unknown[];
-    /**
-     * Define which HttpMethods can be used for queries
-     * @default ['get']
-     */
-    methods: Array<HttpMethod>;
-    /**
-     * Path to the useQuery that will be used to do the useQuery functionality.
-     * It will be used as `import { useQuery } from '${importPath}'`.
-     * It allows both relative and absolute path.
-     * the path will be applied as is, so relative path should be based on the file being generated.
-     * @default '@tanstack/react-query'
-     */
-    importPath?: string;
-};
-type QueryOptions = object;
-type Mutate = {
-    /**
-     * Define the way of passing through the queryParams, headerParams and data.
-     * @default `'hook'`
-     */
-    variablesType: 'mutate' | 'hook';
-    /**
-     * Define which HttpMethods can be used for mutations
-     * @default ['post', 'put', 'delete']
-     */
-    methods: Array<HttpMethod>;
-    /**
-     * Path to the useQuery that will be used to do the useQuery functionality.
-     * It will be used as `import { useQuery } from '${importPath}'`.
-     * It allows both relative and absolute path.
-     * the path will be applied as is, so relative path should be based on the file being generated.
-     * @default '@tanstack/react-query'
-     */
-    importPath?: string;
-};
-type Infinite = {
-    /**
-     * Specify the params key used for `pageParam`.
-     * Used inside `useInfiniteQuery`, `createInfiniteQueries`, `createInfiniteQuery`
-     * @default `'id'`
-     */
-    queryParam: string;
-    /**
-     * Which field of the data will be used, set it to undefined when no cursor is known.
-     */
-    cursorParam?: string | undefined;
-    /**
-     * The initial value, the value of the first page.
-     * @default `0`
-     */
-    initialPageParam: unknown;
-};
-type Options = {
-    output?: {
-        /**
-         * Output to save the @tanstack/query hooks.
-         * @default `"hooks"`
-         */
-        path: string;
-        /**
-         * Name to be used for the `export * as {{exportAs}} from './'`
-         */
-        exportAs?: string;
-        /**
-         * Add an extension to the generated imports and exports, default it will not use an extension
-         */
-        extName?: KubbFile.Extname;
-        /**
-         * Define what needs to exported, here you can also disable the export of barrel files
-         * @default `'barrel'`
-         */
-        exportType?: 'barrel' | 'barrelNamed' | false;
-    };
-    /**
-     * Group the @tanstack/query hooks based on the provided name.
-     */
-    group?: {
-        /**
-         * Tag will group based on the operation tag inside the Swagger file
-         */
-        type: 'tag';
-        /**
-         * Relative path to save the grouped @tanstack/query hooks.
-         *
-         * `{{tag}}` will be replaced by the current tagName.
-         * @example `${output}/{{tag}}Controller` => `hooks/PetController`
-         * @default `${output}/{{tag}}Controller`
-         */
-        output?: string;
-        /**
-         * Name to be used for the `export * as {{exportAs}} from './`
-         * @default `"{{tag}}Hooks"`
-         */
-        exportAs?: string;
-    };
-    client?: {
-        /**
-         * Path to the client that will be used to do the API calls.
-         * It will be used as `import client from '${client.importPath}'`.
-         * It allows both relative and absolute path.
-         * the path will be applied as is, so relative path should be based on the file being generated.
-         * @default '@kubb/plugin-client/client'
-         */
-        importPath?: string;
-    };
-    /**
-     * ReturnType that needs to be used when calling client().
-     *
-     * `Data` will return ResponseConfig[data].
-     *
-     * `Full` will return ResponseConfig.
-     * @default `'data'`
-     * @private
-     */
-    /**
-     * ReturnType that needs to be used when calling client().
-     *
-     * `Data` will return ResponseConfig[data].
-     *
-     * `Full` will return ResponseConfig.
-     * @default `'data'`
-     * @private
-     */
-    dataReturnType?: 'data' | 'full';
-    /**
-     * How to pass your pathParams.
-     *
-     * `object` will return the pathParams as an object.
-     *
-     * `inline` will return the pathParams as comma separated params.
-     * @default `'inline'`
-     * @private
-     */
-    pathParamsType?: 'object' | 'inline';
-    /**
-     * Which parser can be used before returning the data to `@tanstack/query`.
-     * `'zod'` will use `@kubb/plugin-zod` to parse the data.
-     */
-    parser?: 'zod';
-    /**
-     * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
-     */
-    exclude?: Array<Exclude>;
-    /**
-     * Array containing include parameters to include tags/operations/methods/paths.
-     */
-    include?: Array<Include>;
-    /**
-     * Array containing override parameters to override `options` based on tags/operations/methods/paths.
-     */
-    override?: Array<Override<ResolvedOptions>>;
-    /**
-     * When set, an infiniteQuery hooks will be added.
-     */
-    infinite?: Partial<Infinite> | false;
-    /**
-     * When set, a suspenseQuery hooks will be added.
-     */
-    suspense?: Partial<Suspense> | false;
-    /**
-     * Override some useQuery behaviours.
-     */
-    query?: Partial<Query> | false;
-    queryOptions?: Partial<QueryOptions> | false;
-    /**
-     * Override some useMutation behaviours.
-     */
-    mutate?: Mutate | false;
-    transformers?: {
-        /**
-         * Customize the names based on the type that is provided by the plugin.
-         */
-        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
-    };
-    /**
-     * Make it possible to override one of the templates
-     */
-    templates?: Partial<Templates>;
-};
-type ResolvedOptions = {
-    client: Required<NonNullable<PluginReactQuery['options']['client']>>;
-    dataReturnType: NonNullable<PluginReactQuery['options']['dataReturnType']>;
-    pathParamsType: NonNullable<PluginReactQuery['options']['pathParamsType']>;
-    parser: PluginReactQuery['options']['parser'];
-    /**
-     * Only used of infinite
-     */
-    infinite: Infinite | false;
-    suspense: Suspense | false;
-    query: Query | false;
-    queryOptions: QueryOptions | false;
-    mutate: Mutate | false;
-    templates: NonNullable<Templates>;
-};
-type PluginReactQuery = PluginFactoryOptions<'plugin-react-query', Options, ResolvedOptions, never, ResolvePathOptions>;
-
-export { Mutation as M, type Options as O, type PluginReactQuery as P, Query$1 as Q, QueryKey as a, QueryOptions$1 as b };

package/src/OperationGenerator.tsx

@@ -1,57 +0,0 @@
-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 { 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 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

@@ -1,69 +0,0 @@
-import client from "@kubb/plugin-client/client";
-import type { UseBaseQueryOptions, UseQueryResult, QueryKey, WithRequired } from "@tanstack/react-query";
-import { useQuery } 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;
-}