@kubb/plugin-react-query 5.0.0-alpha.9 → 5.0.0-beta.100

package/dist/types-D5S7Ny9r.d.ts

@@ -1,270 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
-import { ClientImportPath, PluginClient } from "@kubb/plugin-client";
-import { Exclude, Include, OperationSchemas, Override, ResolvePathOptions } from "@kubb/plugin-oas";
-import { HttpMethod, Oas, Operation, contentType } from "@kubb/oas";
-import { FunctionParams } from "@kubb/react-fabric";
-import { Generator as Generator$1 } from "@kubb/plugin-oas/generators";
-import { FabricReactNode } from "@kubb/react-fabric/types";
-
-//#region ../../internals/tanstack-query/src/types.d.ts
-type ParamsCasing = 'camelcase' | undefined;
-type PathParamsType = 'object' | 'inline';
-type TransformerProps = {
-  operation: Operation;
-  schemas: OperationSchemas;
-  casing: ParamsCasing;
-};
-type Transformer = (props: TransformerProps) => unknown[];
-//#endregion
-//#region ../../internals/tanstack-query/src/components/MutationKey.d.ts
-type Props$1 = {
-  name: string;
-  typeName: string;
-  typeSchemas: OperationSchemas;
-  operation: Operation;
-  paramsCasing: ParamsCasing;
-  pathParamsType: PathParamsType;
-  transformer: Transformer | undefined;
-};
-type GetParamsProps$1 = {
-  pathParamsType: PathParamsType;
-  typeSchemas: OperationSchemas;
-};
-declare function MutationKey$1({
-  name,
-  typeSchemas,
-  pathParamsType,
-  paramsCasing,
-  operation,
-  typeName,
-  transformer
-}: Props$1): FabricReactNode;
-declare namespace MutationKey$1 {
-  var getParams: ({}: GetParamsProps$1) => FunctionParams;
-  var getTransformer: Transformer;
-}
-//#endregion
-//#region ../../internals/tanstack-query/src/components/QueryKey.d.ts
-type Props = {
-  name: string;
-  typeName: string;
-  typeSchemas: OperationSchemas;
-  operation: Operation;
-  paramsCasing: ParamsCasing;
-  pathParamsType: PathParamsType;
-  transformer: Transformer | undefined;
-};
-type GetParamsProps = {
-  paramsCasing: ParamsCasing;
-  pathParamsType: PathParamsType;
-  typeSchemas: OperationSchemas;
-};
-declare function QueryKey$1({
-  name,
-  typeSchemas,
-  paramsCasing,
-  pathParamsType,
-  operation,
-  typeName,
-  transformer
-}: Props): FabricReactNode;
-declare namespace QueryKey$1 {
-  var getParams: ({
-    pathParamsType,
-    paramsCasing,
-    typeSchemas
-  }: GetParamsProps) => FunctionParams;
-  var getTransformer: Transformer;
-}
-//#endregion
-//#region src/types.d.ts
-type Suspense = object;
-/**
- * Customize the queryKey
- */
-type QueryKey = Transformer;
-/**
- * Customize the mutationKey
- */
-type MutationKey = Transformer;
-type Query = {
-  /**
-   * Define which HttpMethods can be used for queries
-   * @default ['get']
-   */
-  methods: Array<HttpMethod>;
-  /**
-   * Path to the useQuery hook for useQuery functionality.
-   * Used as `import { useQuery } from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default '@tanstack/react-query'
-   */
-  importPath?: string;
-};
-type Mutation = {
-  /**
-   * Define which HttpMethods can be used for mutations
-   * @default ['post', 'put', 'delete']
-   */
-  methods: Array<HttpMethod>;
-  /**
-   * Path to the useQuery hook for useQuery functionality.
-   * Used as `import { useQuery } from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default '@tanstack/react-query'
-   */
-  importPath?: string;
-};
-type Infinite = {
-  /**
-   * Specify the params key used for `pageParam`.
-   * @default 'id'
-   */
-  queryParam: string;
-  /**
-   * Which field of the data is used, set it to undefined when no cursor is known.
-   * @deprecated Use `nextParam` and `previousParam` instead for more flexible pagination handling.
-   */
-  cursorParam?: string | undefined;
-  /**
-   * Which field of the data is used to get the cursor for the next page.
-   * Supports dot notation (e.g. 'pagination.next.id') or array path (e.g. ['pagination', 'next', 'id']) to access nested fields.
-   */
-  nextParam?: string | string[] | undefined;
-  /**
-   * Which field of the data is used to get the cursor for the previous page.
-   * Supports dot notation (e.g. 'pagination.prev.id') or array path (e.g. ['pagination', 'prev', 'id']) to access nested fields.
-   */
-  previousParam?: string | string[] | undefined;
-  /**
-   * The initial value, the value of the first page.
-   * @default 0
-   */
-  initialPageParam: unknown;
-};
-type CustomOptions = {
-  /**
-   * Path to the hook that is used to customize the hook options.
-   * It used as `import ${customOptions.name} from '${customOptions.importPath}'`.
-   * It allows both relative and absolute paths but be aware that we will not change the path.
-   */
-  importPath: string;
-  /**
-   * Name of the exported hook that is used to customize the hook options.
-   * It used as `import ${customOptions.name} from '${customOptions.importPath}'`.
-   * @default 'useCustomHookOptions'
-   */
-  name?: string;
-};
-type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'hooks', barrelType: 'named' }
-   */
-  output?: Output<Oas>;
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
-   */
-  contentType?: contentType;
-  /**
-   * Group the @tanstack/query hooks based on the provided name.
-   */
-  group?: Group;
-  client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>;
-  /**
-   * 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>>;
-  /**
-   * How to style your params, by default no casing is applied
-   * - 'camelcase' uses camelcase for the params names
-   */
-  paramsCasing?: 'camelcase';
-  /**
-   * How to pass your params.
-   * - 'object' returns the params and pathParams as an object.
-   * - 'inline' returns the params as comma separated params.
-   * @default 'inline'
-   */
-  paramsType?: 'object' | 'inline';
-  /**
-   * How to pass your pathParams.
-   * - 'object' returns the pathParams as an object.
-   * - 'inline': returns the pathParams as comma separated params.
-   * @default 'inline'
-   */
-  pathParamsType?: PluginClient['options']['pathParamsType'];
-  /**
-   * When set, an infiniteQuery hooks is added.
-   */
-  infinite?: Partial<Infinite> | false;
-  /**
-   * When set, a suspenseQuery hooks is added.
-   */
-  suspense?: Partial<Suspense> | false;
-  queryKey?: QueryKey;
-  /**
-   * Override some useQuery behaviors.
-   */
-  query?: Partial<Query> | false;
-  mutationKey?: MutationKey;
-  /**
-   * Override some useMutation behaviors.
-   */
-  mutation?: Partial<Mutation> | false;
-  /**
-   * When set, a custom hook is used to customize the options of the generated hooks.
-   * It will also generate a `HookOptions` type that can be used to type the custom options of each hook for type-safety.
-   */
-  customOptions?: CustomOptions;
-  /**
-   * Which parser should be used before returning the data to `@tanstack/query`.
-   * `'zod'` uses `@kubb/plugin-zod` to parse the data.
-   */
-  parser?: PluginClient['options']['parser'];
-  transformers?: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
-  };
-  /**
-   * Define some generators next to the react-query generators
-   */
-  generators?: Array<Generator$1<PluginReactQuery>>;
-};
-type ResolvedOptions = {
-  output: Output<Oas>;
-  group: Options['group'];
-  client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>;
-  parser: Required<NonNullable<Options['parser']>>;
-  pathParamsType: NonNullable<Options['pathParamsType']>;
-  paramsCasing: Options['paramsCasing'];
-  paramsType: NonNullable<Options['paramsType']>;
-  /**
-   * Only used of infinite
-   */
-  infinite: NonNullable<Infinite> | false;
-  suspense: Suspense | false;
-  queryKey: QueryKey | undefined;
-  query: NonNullable<Required<Query>> | false;
-  mutationKey: MutationKey | undefined;
-  mutation: NonNullable<Required<Mutation>> | false;
-  customOptions: NonNullable<Required<CustomOptions>> | undefined;
-};
-type PluginReactQuery = PluginFactoryOptions<'plugin-react-query', Options, ResolvedOptions, never, ResolvePathOptions>;
-//#endregion
-export { MutationKey$1 as a, QueryKey$1 as i, Options as n, PluginReactQuery as r, Infinite as t };
-//# sourceMappingURL=types-D5S7Ny9r.d.ts.map

package/src/components/InfiniteQuery.tsx

@@ -1,220 +0,0 @@
-import { isAllOptional, isOptional, type Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type { Infinite, PluginReactQuery } from '../types.ts'
-import { QueryKey } from './QueryKey.tsx'
-import { QueryOptions } from './QueryOptions.tsx'
-
-type Props = {
-  /**
-   * Name of the function
-   */
-  name: string
-  queryOptionsName: string
-  queryKeyName: string
-  queryKeyTypeName: string
-  typeSchemas: OperationSchemas
-  operation: Operation
-  paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
-  paramsType: PluginReactQuery['resolvedOptions']['paramsType']
-  pathParamsType: PluginReactQuery['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginReactQuery['resolvedOptions']['client']['dataReturnType']
-  initialPageParam: Infinite['initialPageParam']
-  queryParam?: Infinite['queryParam']
-  customOptions: PluginReactQuery['resolvedOptions']['customOptions']
-}
-
-type GetParamsProps = {
-  paramsType: PluginReactQuery['resolvedOptions']['paramsType']
-  paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
-  pathParamsType: PluginReactQuery['resolvedOptions']['pathParamsType']
-  typeSchemas: OperationSchemas
-  pageParamGeneric: string
-}
-
-function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas, pageParamGeneric }: GetParamsProps) {
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, {
-      typed: true,
-      casing: paramsCasing,
-    })
-
-    const children = {
-      ...pathParams,
-      data: typeSchemas.request?.name
-        ? {
-            type: typeSchemas.request?.name,
-            optional: isOptional(typeSchemas.request?.schema),
-          }
-        : undefined,
-      params: typeSchemas.queryParams?.name
-        ? {
-            type: typeSchemas.queryParams?.name,
-            optional: isOptional(typeSchemas.queryParams?.schema),
-          }
-        : undefined,
-      headers: typeSchemas.headerParams?.name
-        ? {
-            type: typeSchemas.headerParams?.name,
-            optional: isOptional(typeSchemas.headerParams?.schema),
-          }
-        : undefined,
-    }
-
-    // Check if all children are optional or undefined
-    const allChildrenAreOptional = Object.values(children).every((child) => !child || child.optional)
-
-    return FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children,
-        default: allChildrenAreOptional ? '{}' : undefined,
-      },
-      options: {
-        type: `
-{
-  query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'}
-}
-`,
-        default: '{}',
-      },
-    })
-  }
-
-  return FunctionParams.factory({
-    pathParams: typeSchemas.pathParams?.name
-      ? {
-          mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-          children: getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-          default: isAllOptional(typeSchemas.pathParams?.schema) ? '{}' : undefined,
-        }
-      : undefined,
-    data: typeSchemas.request?.name
-      ? {
-          type: typeSchemas.request?.name,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: typeSchemas.queryParams?.name,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: typeSchemas.headerParams?.name,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
-    options: {
-      type: `
-{
-  query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'}
-}
-`,
-      default: '{}',
-    },
-  })
-}
-
-export function InfiniteQuery({
-  name,
-  queryKeyTypeName,
-  queryOptionsName,
-  queryKeyName,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  dataReturnType,
-  typeSchemas,
-  operation,
-  initialPageParam,
-  queryParam,
-  customOptions,
-}: Props): FabricReactNode {
-  const responseType = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const errorType = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-  const isInitialPageParamDefined = initialPageParam !== undefined && initialPageParam !== null
-  const fallbackPageParamType =
-    typeof initialPageParam === 'number'
-      ? 'number'
-      : typeof initialPageParam === 'string'
-        ? initialPageParam.includes(' as ')
-          ? (() => {
-              const parts = initialPageParam.split(' as ')
-              return parts[parts.length - 1] ?? 'unknown'
-            })()
-          : 'string'
-        : typeof initialPageParam === 'boolean'
-          ? 'boolean'
-          : 'unknown'
-  const queryParamType = queryParam && typeSchemas.queryParams?.name ? `${typeSchemas.queryParams?.name}['${queryParam}']` : undefined
-  const pageParamType = queryParamType ? (isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType) : fallbackPageParamType
-  const returnType = 'UseInfiniteQueryResult<TData, TError> & { queryKey: TQueryKey }'
-  const generics = [
-    `TQueryFnData = ${responseType}`,
-    `TError = ${errorType}`,
-    'TData = InfiniteData<TQueryFnData>',
-    `TQueryKey extends QueryKey = ${queryKeyTypeName}`,
-    `TPageParam = ${pageParamType}`,
-  ]
-
-  const queryKeyParams = QueryKey.getParams({
-    pathParamsType,
-    typeSchemas,
-    paramsCasing,
-  })
-  const queryOptionsParams = QueryOptions.getParams({
-    paramsType,
-    pathParamsType,
-    typeSchemas,
-    paramsCasing,
-  })
-  const params = getParams({
-    paramsCasing,
-    paramsType,
-    pathParamsType,
-    typeSchemas,
-    pageParamGeneric: 'TPageParam',
-  })
-
-  const queryOptions = `${queryOptionsName}(${queryOptionsParams.toCall()})`
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function
-        name={name}
-        export
-        generics={generics.join(', ')}
-        params={params.toConstructor()}
-        JSDoc={{
-          comments: getComments(operation),
-        }}
-      >
-        {`
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParams.toCall()})
-       ${customOptions ? `const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${operation.getOperationId()}' })` : ''}
-
-       const query = useInfiniteQuery({
-        ...${queryOptions},${customOptions ? '\n...customOptions,' : ''}
-        ...resolvedOptions,
-        queryKey,
-       } as unknown as InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `}
-      </Function>
-    </File.Source>
-  )
-}
-
-InfiniteQuery.getParams = getParams