@kubb/plugin-swr 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/components/SchemaType.tsx

@@ -1,59 +0,0 @@
-import { Type, useApp } from '@kubb/react'
-
-import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
-import type { ReactNode } from 'react'
-import type { PluginSwr } from '../types.ts'
-import { pluginTsName } from '@kubb/plugin-ts'
-
-type Props = {
-  factory: {
-    name: string
-  }
-}
-
-export function SchemaType({ factory }: Props): ReactNode {
-  const {
-    plugin: {
-      options: { dataReturnType },
-    },
-  } = useApp<PluginSwr>()
-  const { getSchemas } = useOperationManager()
-  const operation = useOperation()
-
-  const schemas = getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' })
-
-  const [TData, TError, TRequest, TPathParams, TQueryParams, THeaderParams, TResponse] = [
-    schemas.response.name,
-    schemas.errors?.map((item) => item.name).join(' | ') || 'never',
-    schemas.request?.name || 'never',
-    schemas.pathParams?.name || 'never',
-    schemas.queryParams?.name || 'never',
-    schemas.headerParams?.name || 'never',
-    schemas.response.name,
-  ]
-
-  const clientType = `${factory.name}Client`
-
-  return (
-    <>
-      <Type name={clientType}>{`typeof client<${TResponse}, ${TError}, ${TRequest}>`}</Type>
-      <Type name={factory.name}>
-        {`
-        {
-          data: ${TData}
-          error: ${TError}
-          request: ${TRequest}
-          pathParams: ${TPathParams}
-          queryParams: ${TQueryParams}
-          headerParams: ${THeaderParams}
-          response: ${dataReturnType === 'data' ? TData : `Awaited<ReturnType<${clientType}>>`}
-          client: {
-            parameters: Partial<Parameters<${clientType}>[0]>
-            return: Awaited<ReturnType<${clientType}>>
-          }
-        }
-        `}
-      </Type>
-    </>
-  )
-}

package/src/components/__snapshots__/Mutation/Pets.ts

@@ -1,42 +0,0 @@
-type CreatePetsClient = typeof client<CreatePetsMutationResponse, never, CreatePetsMutationRequest>
-type CreatePets = {
-  data: CreatePetsMutationResponse
-  error: never
-  request: CreatePetsMutationRequest
-  pathParams: never
-  queryParams: never
-  headerParams: never
-  response: CreatePetsMutationResponse
-  client: {
-    parameters: Partial<Parameters<CreatePetsClient>[0]>
-    return: Awaited<ReturnType<CreatePetsClient>>
-  }
-}
-
-/**
- * @summary Create a pet
- * @link /pets
- */
-export function useCreatePets(options?: {
-  mutation?: SWRMutationConfiguration<CreatePets['response'], CreatePets['error']>
-  client?: CreatePets['client']['parameters']
-  shouldFetch?: boolean
-}): SWRMutationResponse<CreatePets['response'], CreatePets['error']> {
-  const { mutation: mutationOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
-
-  const url = `/pets` as const
-  return useSWRMutation<CreatePets['response'], CreatePets['error'], typeof url | null>(
-    shouldFetch ? url : null,
-    async (_url, { arg: data }) => {
-      const res = await client<CreatePets['data'], CreatePets['error'], CreatePets['request']>({
-        method: 'post',
-        url,
-        data,
-        ...clientOptions,
-      })
-
-      return res.data
-    },
-    mutationOptions,
-  )
-}

package/src/components/__snapshots__/Query/showPetById.ts

@@ -1,55 +0,0 @@
-type ShowPetByIdClient = typeof client<ShowPetByIdQueryResponse, never, never>
-type ShowPetById = {
-  data: ShowPetByIdQueryResponse
-  error: never
-  request: never
-  pathParams: ShowPetByIdPathParams
-  queryParams: never
-  headerParams: never
-  response: ShowPetByIdQueryResponse
-  client: {
-    parameters: Partial<Parameters<ShowPetByIdClient>[0]>
-    return: Awaited<ReturnType<ShowPetByIdClient>>
-  }
-}
-
-export function ShowPetByIdQueryOptions<TData = ShowPetById['response']>(
-  petId: ShowPetByIdPathParams['petId'],
-  testId: ShowPetByIdPathParams['testId'],
-  options: ShowPetById['client']['parameters'] = {},
-): SWRConfiguration<TData, ShowPetById['error']> {
-  return {
-    fetcher: async () => {
-      const res = await client<TData, ShowPetById['error']>({
-        method: 'get',
-        url: `/pets/${petId}`,
-        ...options,
-      })
-
-      return res.data
-    },
-  }
-}
-/**
- * @summary Info for a specific pet
- * @link /pets/:petId
- */
-export function useShowPetById<TData = ShowPetById['response']>(
-  petId: ShowPetByIdPathParams['petId'],
-  testId: ShowPetByIdPathParams['testId'],
-  options?: {
-    query?: SWRConfiguration<TData, ShowPetById['error']>
-    client?: ShowPetById['client']['parameters']
-    shouldFetch?: boolean
-  },
-): SWRResponse<TData, ShowPetById['error']> {
-  const { query: queryOptions, client: clientOptions = {}, shouldFetch = true } = options ?? {}
-
-  const url = `/pets/${petId}`
-  const query = useSWR<TData, ShowPetById['error'], typeof url | null>(shouldFetch ? url : null, {
-    ...ShowPetByIdQueryOptions<TData>(petId, testId, clientOptions),
-    ...queryOptions,
-  })
-
-  return query
-}