@orpc/react 0.10.0-beta.1 → 0.11.0

package/src/procedure-hooks.test-d.ts

@@ -1,321 +0,0 @@
-import type { SchemaInput, SchemaOutput } from '@orpc/contract'
-import type { DefaultError, InfiniteData } from '@tanstack/react-query'
-import {} from '@testing-library/react'
-import {
-  ORPCContext,
-  type UserCreateInputSchema,
-  type UserFindInputSchema,
-  type UserListInputSchema,
-  type UserListOutputSchema,
-  type UserSchema,
-} from '../tests/orpc'
-import { createProcedureHooks } from './procedure-hooks'
-
-describe('useQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  it('simple', () => {
-    expectTypeOf<Parameters<typeof hooks.useQuery>[0]>().toEqualTypeOf<
-      SchemaInput<typeof UserFindInputSchema>
-    >()
-
-    const query = hooks.useQuery({ id: '1' })
-
-    expectTypeOf(query.data).toEqualTypeOf<
-      SchemaOutput<typeof UserSchema> | undefined
-    >()
-  })
-
-  it('with select', async () => {
-    const query = hooks.useQuery(
-      { id: '1' },
-      {
-        select(data) {
-          expectTypeOf(data).toEqualTypeOf<SchemaOutput<typeof UserSchema>>()
-
-          return {
-            select: data,
-          }
-        },
-      },
-    )
-
-    expectTypeOf(query.data).toEqualTypeOf<
-      { select: SchemaOutput<typeof UserSchema> } | undefined
-    >()
-  })
-})
-
-describe('useInfiniteQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserListInputSchema,
-    typeof UserListOutputSchema,
-    SchemaOutput<typeof UserListOutputSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'list'],
-  })
-
-  it('simple', () => {
-    expectTypeOf<
-      Parameters<typeof hooks.useInfiniteQuery>[0]['input']
-    >().toMatchTypeOf<{
-      keyword?: string
-      cursor?: never /** prevent user to set cursor */
-    }>()
-
-    const query = hooks.useInfiniteQuery({
-      input: { keyword: '1' },
-      getNextPageParam(lastPage) {
-        return lastPage.nextCursor
-      },
-    })
-
-    expectTypeOf(query.data).toEqualTypeOf<
-      | undefined
-      | InfiniteData<
-        SchemaOutput<typeof UserListOutputSchema>,
-          number | undefined
-      >
-    >()
-  })
-
-  it('with select', () => {
-    const query = hooks.useInfiniteQuery({
-      input: { keyword: '1' },
-      initialPageParam: 12344,
-      getNextPageParam(lastPage) {
-        return lastPage.nextCursor
-      },
-      select(data) {
-        expectTypeOf(data).toEqualTypeOf<
-          InfiniteData<
-            SchemaOutput<typeof UserListOutputSchema>,
-            number | undefined
-          >
-        >()
-
-        return {
-          select: data,
-        }
-      },
-    })
-
-    expectTypeOf(query.data).toEqualTypeOf<
-      | undefined
-      | {
-        select: InfiniteData<
-          SchemaOutput<typeof UserListOutputSchema>,
-            number | undefined
-        >
-      }
-    >()
-  })
-})
-
-describe('useSuspenseQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  it('simple', () => {
-    expectTypeOf<Parameters<typeof hooks.useSuspenseQuery>[0]>().toEqualTypeOf<
-      SchemaInput<typeof UserFindInputSchema>
-    >()
-
-    const query = hooks.useSuspenseQuery({ id: '1' })
-
-    expectTypeOf(query.data).toEqualTypeOf<SchemaOutput<typeof UserSchema>>()
-  })
-
-  it('with select', async () => {
-    const query = hooks.useSuspenseQuery(
-      { id: '1' },
-      {
-        select(data) {
-          expectTypeOf(data).toEqualTypeOf<SchemaOutput<typeof UserSchema>>()
-
-          return {
-            select: data,
-          }
-        },
-      },
-    )
-
-    expectTypeOf(query.data).toEqualTypeOf<{
-      select: SchemaOutput<typeof UserSchema>
-    }>()
-  })
-})
-
-describe('useSuspenseInfiniteQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserListInputSchema,
-    typeof UserListOutputSchema,
-    SchemaOutput<typeof UserListOutputSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'list'],
-  })
-
-  it('simple', () => {
-    expectTypeOf<
-      Parameters<typeof hooks.useSuspenseInfiniteQuery>[0]['input']
-    >().toMatchTypeOf<{
-      keyword?: string
-      cursor?: never /** prevent user to set cursor */
-    }>()
-
-    const query = hooks.useSuspenseInfiniteQuery({
-      input: { keyword: '1' },
-      getNextPageParam(lastPage) {
-        return lastPage.nextCursor
-      },
-    })
-
-    expectTypeOf(query.data).toEqualTypeOf<
-      InfiniteData<
-        SchemaOutput<typeof UserListOutputSchema>,
-        number | undefined
-      >
-    >()
-  })
-
-  it('with select', () => {
-    const query = hooks.useSuspenseInfiniteQuery({
-      input: {},
-      initialPageParam: 12344,
-      getNextPageParam(lastPage) {
-        return lastPage.nextCursor
-      },
-      select(data) {
-        expectTypeOf(data).toEqualTypeOf<
-          InfiniteData<
-            SchemaOutput<typeof UserListOutputSchema>,
-            number | undefined
-          >
-        >()
-
-        return {
-          select: data,
-        }
-      },
-    })
-
-    expectTypeOf(query.data).toEqualTypeOf<{
-      select: InfiniteData<
-        SchemaOutput<typeof UserListOutputSchema>,
-        number | undefined
-      >
-    }>()
-  })
-})
-
-describe('usePrefetchQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  it('simple', () => {
-    expectTypeOf<Parameters<typeof hooks.usePrefetchQuery>[0]>().toEqualTypeOf<
-      SchemaInput<typeof UserFindInputSchema>
-    >()
-
-    const query = hooks.usePrefetchQuery({ id: '1' })
-
-    expectTypeOf(query).toEqualTypeOf<void>()
-  })
-})
-
-describe('usePrefetchInfiniteQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserListInputSchema,
-    typeof UserListOutputSchema,
-    SchemaOutput<typeof UserListOutputSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'list'],
-  })
-
-  it('simple', () => {
-    expectTypeOf<
-      Parameters<typeof hooks.usePrefetchInfiniteQuery>[0]['input']
-    >().toMatchTypeOf<{
-      keyword?: string
-      cursor?: never /** prevent user to set cursor */
-    }>()
-
-    hooks.usePrefetchInfiniteQuery({ input: { keyword: '1' } })
-
-    hooks.usePrefetchInfiniteQuery(
-      { keyword: '1' },
-      // @ts-expect-error required getNextPageParam when pages is set
-      {
-        initialPageParam: 12344,
-        pages: 3,
-      },
-    )
-
-    const query = hooks.usePrefetchInfiniteQuery({
-      input: { keyword: '1' },
-      initialPageParam: 12344,
-      pages: 3,
-      getNextPageParam(lastPage) {
-        return lastPage.nextCursor
-      },
-    })
-
-    expectTypeOf(query).toEqualTypeOf<void>()
-  })
-})
-
-describe('useMutation', () => {
-  const hooks = createProcedureHooks<
-    typeof UserCreateInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'create'],
-  })
-
-  it('simple', () => {
-    const mutation = hooks.useMutation()
-
-    expectTypeOf<Parameters<typeof mutation.mutate>[0]>().toEqualTypeOf<
-      SchemaInput<typeof UserCreateInputSchema>
-    >()
-
-    expectTypeOf(mutation.data).toEqualTypeOf<
-      SchemaOutput<typeof UserSchema> | undefined
-    >()
-  })
-
-  it('with options', () => {
-    hooks.useMutation({
-      onSuccess(data) {
-        expectTypeOf(data).toEqualTypeOf<SchemaOutput<typeof UserSchema>>()
-      },
-      onError(error) {
-        expectTypeOf(error).toEqualTypeOf<DefaultError>()
-      },
-    })
-  })
-})

package/src/procedure-hooks.test.tsx

@@ -1,388 +0,0 @@
-import type { SchemaOutput } from '@orpc/contract'
-import { renderHook, screen, waitFor } from '@testing-library/react'
-import {
-  ORPCContext,
-  queryClient,
-  type UserCreateInputSchema,
-  type UserFindInputSchema,
-  type UserListInputSchema,
-  type UserListOutputSchema,
-  type UserSchema,
-  wrapper,
-} from '../tests/orpc'
-import { createProcedureHooks } from './procedure-hooks'
-
-beforeEach(() => {
-  queryClient.clear()
-})
-
-describe('useQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  it('on success', async () => {
-    const { result } = renderHook(() => hooks.useQuery({ id: '1' }), {
-      wrapper,
-    })
-
-    await waitFor(() => expect(result.current.status).toBe('success'))
-
-    expect(result.current.data).toEqual({
-      id: '1',
-      name: 'name-1',
-    })
-
-    expect(
-      queryClient.getQueriesData({
-        exact: true,
-        queryKey: [['user', 'find'], { input: { id: '1' }, type: 'query' }],
-      })[0]?.[1],
-    ).toBe(result.current.data)
-  })
-
-  it('on error', async () => {
-    // @ts-expect-error invalid input
-    const { result } = renderHook(() => hooks.useQuery({ id: {} }), {
-      wrapper,
-    })
-
-    await waitFor(() => expect(result.current.status).toBe('error'))
-
-    expect((result.current.error as any).message).toEqual(
-      'Validation input failed',
-    )
-  })
-})
-
-describe('useInfiniteQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserListInputSchema,
-    typeof UserListOutputSchema,
-    SchemaOutput<typeof UserListOutputSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'list'],
-  })
-
-  it('on success', async () => {
-    const { result } = renderHook(
-      () =>
-        hooks.useInfiniteQuery({
-          input: { keyword: '1' },
-          getNextPageParam(lastPage) {
-            return lastPage.nextCursor
-          },
-        }),
-      {
-        wrapper,
-      },
-    )
-
-    await waitFor(() => expect(result.current.status).toBe('success'))
-
-    expect(result.current.data).toMatchObject({
-      pages: [
-        {
-          nextCursor: 2,
-          users: [{ name: 'number-0' }, { name: 'number-1' }],
-        },
-      ],
-      pageParams: [undefined],
-    })
-
-    expect(
-      queryClient.getQueriesData({
-        exact: true,
-        queryKey: [
-          ['user', 'list'],
-          { input: { keyword: '1' }, type: 'infinite' },
-        ],
-      })[0]?.[1],
-    ).toBe(result.current.data)
-
-    result.current.fetchNextPage()
-
-    await waitFor(() => expect(result.current.data?.pages.length).toBe(2))
-
-    expect(result.current.data).toMatchObject({
-      pages: [
-        {
-          nextCursor: 2,
-          users: [{ name: 'number-0' }, { name: 'number-1' }],
-        },
-        {
-          nextCursor: 4,
-          users: [{ name: 'number-2' }, { name: 'number-3' }],
-        },
-      ],
-      pageParams: [undefined, 2],
-    })
-  })
-
-  it('on error', async () => {
-    const { result } = renderHook(
-      () =>
-        hooks.useInfiniteQuery({
-          // @ts-expect-error invalid input
-          input: { keyword: {} },
-          getNextPageParam(lastPage) {
-            return lastPage.nextCursor
-          },
-        }),
-      {
-        wrapper,
-      },
-    )
-
-    await waitFor(() => expect(result.current.status).toBe('error'))
-
-    expect((result.current.error as any).message).toEqual(
-      'Validation input failed',
-    )
-  })
-})
-
-describe('useSuspenseQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  it('on success', async () => {
-    const { result } = renderHook(() => hooks.useSuspenseQuery({ id: '1' }), {
-      wrapper,
-    })
-
-    await waitFor(() => expect(result.current.status).toBe('success'))
-
-    expect(result.current.data).toEqual({
-      id: '1',
-      name: 'name-1',
-    })
-
-    expect(
-      queryClient.getQueriesData({
-        exact: true,
-        queryKey: [['user', 'find'], { input: { id: '1' }, type: 'query' }],
-      })[0]?.[1],
-    ).toBe(result.current.data)
-  })
-
-  it('on error', async () => {
-    // @ts-expect-error invalid input
-    const { result } = renderHook(() => hooks.useSuspenseQuery({ id: {} }), {
-      wrapper,
-    })
-
-    await waitFor(() =>
-      expect(screen.getByTestId('error-boundary')).toHaveTextContent(
-        'Validation input failed',
-      ),
-    )
-  })
-})
-
-describe('useSuspenseInfiniteQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserListInputSchema,
-    typeof UserListOutputSchema,
-    SchemaOutput<typeof UserListOutputSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'list'],
-  })
-
-  it('on success', async () => {
-    const { result } = renderHook(
-      () =>
-        hooks.useSuspenseInfiniteQuery({
-          input: { keyword: '1' },
-          getNextPageParam(lastPage) {
-            return lastPage.nextCursor
-          },
-        }),
-      {
-        wrapper,
-      },
-    )
-
-    await waitFor(() => expect(result.current.status).toBe('success'))
-
-    expect(result.current.data).toMatchObject({
-      pages: [
-        {
-          nextCursor: 2,
-          users: [{ name: 'number-0' }, { name: 'number-1' }],
-        },
-      ],
-      pageParams: [undefined],
-    })
-
-    expect(
-      queryClient.getQueriesData({
-        exact: true,
-        queryKey: [
-          ['user', 'list'],
-          { input: { keyword: '1' }, type: 'infinite' },
-        ],
-      })[0]?.[1],
-    ).toBe(result.current.data)
-
-    result.current.fetchNextPage()
-
-    await waitFor(() => expect(result.current.data?.pages.length).toBe(2))
-
-    expect(result.current.data).toMatchObject({
-      pages: [
-        {
-          nextCursor: 2,
-          users: [{ name: 'number-0' }, { name: 'number-1' }],
-        },
-        {
-          nextCursor: 4,
-          users: [{ name: 'number-2' }, { name: 'number-3' }],
-        },
-      ],
-      pageParams: [undefined, 2],
-    })
-  })
-
-  it('on error', async () => {
-    const { result } = renderHook(
-      () =>
-        hooks.useSuspenseInfiniteQuery({
-          // @ts-expect-error invalid input
-          input: { keyword: {} },
-          getNextPageParam(lastPage) {
-            return lastPage.nextCursor
-          },
-        }),
-      {
-        wrapper,
-      },
-    )
-
-    await waitFor(() =>
-      expect(screen.getByTestId('error-boundary')).toHaveTextContent(
-        'Validation input failed',
-      ),
-    )
-  })
-})
-
-describe('usePrefetchQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  it('on success', async () => {
-    renderHook(() => hooks.usePrefetchQuery({ id: '1' }), {
-      wrapper,
-    })
-
-    await waitFor(() =>
-      expect(
-        queryClient.getQueriesData({
-          exact: true,
-          queryKey: [['user', 'find'], { input: { id: '1' }, type: 'query' }],
-        })[0]?.[1],
-      ).toEqual({
-        id: '1',
-        name: 'name-1',
-      }),
-    )
-  })
-})
-
-describe('usePrefetchInfiniteQuery', () => {
-  const hooks = createProcedureHooks<
-    typeof UserListInputSchema,
-    typeof UserListOutputSchema,
-    SchemaOutput<typeof UserListOutputSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'list'],
-  })
-
-  it('on success', async () => {
-    renderHook(
-      () => hooks.usePrefetchInfiniteQuery({ input: { keyword: '1' } }),
-      {
-        wrapper,
-      },
-    )
-
-    await waitFor(() =>
-      expect(
-        queryClient.getQueriesData({
-          exact: true,
-          queryKey: [
-            ['user', 'list'],
-            { input: { keyword: '1' }, type: 'infinite' },
-          ],
-        })[0]?.[1],
-      ).toMatchObject({
-        pages: [
-          {
-            nextCursor: 2,
-            users: [{ name: 'number-0' }, { name: 'number-1' }],
-          },
-        ],
-        pageParams: [undefined],
-      }),
-    )
-  })
-})
-
-describe('useMutation', () => {
-  const hooks = createProcedureHooks<
-    typeof UserCreateInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'create'],
-  })
-
-  it('on success', async () => {
-    const { result } = renderHook(() => hooks.useMutation(), {
-      wrapper,
-    })
-
-    result.current.mutate({ name: 'name-1' })
-
-    await waitFor(() =>
-      expect(result.current.data).toMatchObject({ name: 'name-1' }),
-    )
-  })
-
-  it('on error', async () => {
-    const { result } = renderHook(() => hooks.useMutation(), {
-      wrapper,
-    })
-
-    // @ts-expect-error invalid input
-    result.current.mutate({ name: {} })
-
-    await waitFor(() =>
-      expect((result.current.error as any)?.message).toEqual(
-        'Validation input failed',
-      ),
-    )
-  })
-})