@orpc/react 0.0.0-next.b15d206 → 0.0.0-next.db1f26d

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

@@ -1,151 +0,0 @@
-import type { SchemaInput, SchemaOutput } from '@orpc/contract'
-import type {
-  DefaultError,
-  Mutation,
-  MutationState,
-} from '@tanstack/react-query'
-import {
-  ORPCContext,
-  type UserCreateInputSchema,
-  type UserFindInputSchema,
-  type UserSchema,
-} from '../tests/orpc'
-import { createGeneralHooks } from './general-hooks'
-
-describe('useIsFetching', () => {
-  const hooks = createGeneralHooks<undefined, undefined, unknown>({
-    context: ORPCContext,
-    path: ['user'],
-  })
-
-  const procedureHooks = createGeneralHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  it('simple', () => {
-    const result = hooks.useIsFetching()
-    expectTypeOf(result).toEqualTypeOf<number>()
-  })
-
-  it('with filters', () => {
-    const result = procedureHooks.useIsFetching({
-      input: {},
-    })
-
-    expectTypeOf(result).toEqualTypeOf<number>()
-
-    procedureHooks.useIsFetching({
-      input: {
-        id: '1',
-      },
-    })
-
-    procedureHooks.useIsFetching({
-      input: {
-        // @ts-expect-error invalid id
-        id: 1,
-      },
-    })
-  })
-})
-
-describe('useIsMutating', () => {
-  const hooks = createGeneralHooks<undefined, undefined, unknown>({
-    context: ORPCContext,
-    path: ['user'],
-  })
-
-  const procedureHooks = createGeneralHooks<
-    typeof UserCreateInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'create'],
-  })
-
-  it('simple', () => {
-    const result = hooks.useIsMutating()
-    expectTypeOf(result).toEqualTypeOf<number>()
-  })
-
-  it('with filters', () => {
-    const result = procedureHooks.useIsMutating({
-      // @ts-expect-error input is now allowed on mutation
-      input: {},
-    })
-  })
-})
-
-describe('useMutationState', () => {
-  const hooks = createGeneralHooks<undefined, undefined, unknown>({
-    context: ORPCContext,
-    path: ['user'],
-  })
-
-  const procedureHooks = createGeneralHooks<
-    typeof UserCreateInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'create'],
-  })
-
-  it('simple', () => {
-    const result = hooks.useMutationState()
-    expectTypeOf(result).toEqualTypeOf<
-      MutationState<unknown, DefaultError, unknown>[]
-    >()
-
-    const result2 = procedureHooks.useMutationState()
-    expectTypeOf(result2).toEqualTypeOf<
-      MutationState<
-        SchemaOutput<typeof UserSchema>,
-        DefaultError,
-        SchemaInput<typeof UserCreateInputSchema>
-      >[]
-    >()
-  })
-
-  it('with filters', () => {
-    const result = procedureHooks.useMutationState({
-      filters: {
-        // @ts-expect-error input is now allowed on mutation
-        input: {},
-      },
-    })
-  })
-
-  it('with select', () => {
-    const r1 = hooks.useMutationState({
-      select: (data) => {
-        expectTypeOf(data).toEqualTypeOf<
-          Mutation<unknown, DefaultError, unknown>
-        >()
-        return 1
-      },
-    })
-    expectTypeOf(r1).toEqualTypeOf<number[]>()
-
-    const r2 = procedureHooks.useMutationState({
-      select: (data) => {
-        expectTypeOf(data).toEqualTypeOf<
-          Mutation<
-            SchemaOutput<typeof UserSchema>,
-            DefaultError,
-            SchemaInput<typeof UserCreateInputSchema>
-          >
-        >()
-
-        return '1'
-      },
-    })
-    expectTypeOf(r2).toEqualTypeOf<string[]>()
-  })
-})

package/src/general-hooks.test.tsx

@@ -1,232 +0,0 @@
-import type { SchemaOutput } from '@orpc/contract'
-import { useMutation, useQuery } from '@tanstack/react-query'
-import { renderHook } from '@testing-library/react'
-import {
-  ORPCContext,
-  queryClient,
-  type UserCreateInputSchema,
-  type UserFindInputSchema,
-  type UserSchema,
-  wrapper,
-} from '../tests/orpc'
-import { createGeneralHooks } from './general-hooks'
-
-beforeEach(() => {
-  queryClient.clear()
-})
-
-describe('useIsFetching', () => {
-  const user_hooks = createGeneralHooks<undefined, undefined, unknown>({
-    context: ORPCContext,
-    path: ['user'],
-  })
-
-  const user_find_Hooks = createGeneralHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  const user_create_Hooks = createGeneralHooks<
-    typeof UserCreateInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'create'],
-  })
-
-  it('on success', async () => {
-    const { result } = renderHook(() => user_hooks.useIsFetching(), { wrapper })
-    const { result: result2 } = renderHook(
-      () => user_find_Hooks.useIsFetching(),
-      { wrapper },
-    )
-    const { result: result3 } = renderHook(
-      () => user_find_Hooks.useIsFetching({ input: { id: '12333' } }),
-      { wrapper },
-    )
-    const { result: result4 } = renderHook(
-      () => user_find_Hooks.useIsFetching({ input: { id: 'never' } }),
-      { wrapper },
-    )
-    const { result: result5 } = renderHook(
-      () => user_create_Hooks.useIsFetching(),
-      { wrapper },
-    )
-
-    expect(result.current).toBe(0)
-    expect(result2.current).toBe(0)
-    expect(result3.current).toBe(0)
-    expect(result4.current).toBe(0)
-    expect(result5.current).toBe(0)
-
-    renderHook(() =>
-      useQuery(
-        {
-          queryKey: [
-            ['user', 'find'],
-            { input: { id: '12333' }, type: 'query' },
-          ],
-          queryFn: async () => {
-            await new Promise(resolve => setTimeout(resolve, 100))
-          },
-        },
-        queryClient,
-      ),
-    )
-    renderHook(() =>
-      useQuery(
-        {
-          queryKey: [
-            ['user', 'find'],
-            { input: { id: '12333' }, type: 'infinite' },
-          ],
-          queryFn: async () => {
-            await new Promise(resolve => setTimeout(resolve, 100))
-          },
-        },
-        queryClient,
-      ),
-    )
-
-    await new Promise(resolve => setTimeout(resolve, 50)) // < 100 make sure the query is not finished
-
-    expect(result.current).toBe(2)
-    expect(result2.current).toBe(2)
-    expect(result3.current).toBe(2)
-    expect(result4.current).toBe(0)
-    expect(result5.current).toBe(0)
-  })
-})
-
-describe('useIsMutating', () => {
-  const user_hooks = createGeneralHooks<undefined, undefined, unknown>({
-    context: ORPCContext,
-    path: ['user'],
-  })
-
-  const user_find_Hooks = createGeneralHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  const user_create_Hooks = createGeneralHooks<
-    typeof UserCreateInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'create'],
-  })
-
-  it('on success', async () => {
-    const { result } = renderHook(() => user_hooks.useIsMutating(), { wrapper })
-    const { result: result2 } = renderHook(
-      () => user_find_Hooks.useIsMutating(),
-      { wrapper },
-    )
-    const { result: result3 } = renderHook(
-      () => user_create_Hooks.useIsMutating(),
-      { wrapper },
-    )
-
-    expect(result.current).toBe(0)
-    expect(result2.current).toBe(0)
-    expect(result3.current).toBe(0)
-
-    const { result: mutation } = renderHook(() =>
-      useMutation(
-        {
-          mutationKey: [['user', 'create']],
-          mutationFn: async () => {
-            await new Promise(resolve => setTimeout(resolve, 100))
-          },
-        },
-        queryClient,
-      ),
-    )
-
-    mutation.current.mutate()
-
-    await new Promise(resolve => setTimeout(resolve, 50)) // < 100 make sure the query is not finished
-
-    expect(result.current).toBe(1)
-    expect(result2.current).toBe(0)
-    expect(result3.current).toBe(1)
-  })
-})
-
-describe('useMutationState', () => {
-  const user_hooks = createGeneralHooks<undefined, undefined, unknown>({
-    context: ORPCContext,
-    path: ['user'],
-  })
-
-  const user_find_Hooks = createGeneralHooks<
-    typeof UserFindInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'find'],
-  })
-
-  const user_create_Hooks = createGeneralHooks<
-    typeof UserCreateInputSchema,
-    typeof UserSchema,
-    SchemaOutput<typeof UserSchema>
-  >({
-    context: ORPCContext,
-    path: ['user', 'create'],
-  })
-
-  it('on success', async () => {
-    const { result } = renderHook(() => user_hooks.useMutationState(), {
-      wrapper,
-    })
-    const { result: result2 } = renderHook(
-      () => user_find_Hooks.useMutationState(),
-      { wrapper },
-    )
-    const { result: result3 } = renderHook(
-      () => user_create_Hooks.useMutationState(),
-      { wrapper },
-    )
-
-    expect(result.current.length).toBe(0)
-    expect(result2.current.length).toBe(0)
-    expect(result3.current.length).toBe(0)
-
-    const { result: mutation } = renderHook(() =>
-      useMutation(
-        {
-          mutationKey: [['user', 'create']],
-          mutationFn: async () => {
-            await new Promise(resolve => setTimeout(resolve, 100))
-          },
-        },
-        queryClient,
-      ),
-    )
-
-    mutation.current.mutate({ name: 'unnoq' } as any)
-
-    await new Promise(resolve => setTimeout(resolve, 50)) // < 100 make sure the query is not finished
-
-    expect(result.current.length).toBe(1)
-    expect(result2.current.length).toBe(0)
-    expect(result3.current.length).toBe(1)
-
-    expect(result.current[0]).toEqual(result3.current[0])
-
-    expect(result.current[0]?.variables).toEqual({ name: 'unnoq' })
-  })
-})

package/src/general-hooks.ts

@@ -1,101 +0,0 @@
-import type { Schema, SchemaInput, SchemaOutput } from '@orpc/contract'
-import type { PartialDeep, SetOptional } from '@orpc/shared'
-import type { ORPCQueryFilters } from './tanstack-query'
-import {
-  type DefaultError,
-  type Mutation,
-  type MutationFilters,
-  type MutationState,
-  useIsFetching,
-  useIsMutating,
-  useMutationState,
-} from '@tanstack/react-query'
-import { type ORPCContext, useORPCContext } from './react-context'
-import { getMutationKeyFromPath, getQueryKeyFromPath } from './tanstack-key'
-
-export interface GeneralHooks<
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-  TFuncOutput extends SchemaOutput<TOutputSchema>,
-> {
-  useIsFetching: (
-    filers?: ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>,
-  ) => number
-  useIsMutating: (filters?: SetOptional<MutationFilters, 'mutationKey'>) => number
-
-  useMutationState: <
-    UResult = MutationState<
-      SchemaOutput<TOutputSchema, TFuncOutput>,
-      DefaultError,
-      SchemaInput<TInputSchema>
-    >,
-  >(options?: {
-    filters?: SetOptional<MutationFilters, 'mutationKey'>
-    select?: (
-      mutation: Mutation<
-        SchemaOutput<TOutputSchema, TFuncOutput>,
-        DefaultError,
-        SchemaInput<TInputSchema>
-      >,
-    ) => UResult
-  }
-  ) => UResult[]
-}
-
-export interface CreateGeneralHooksOptions {
-  context: ORPCContext<any>
-
-  /**
-   * The path of the router or procedure on server.
-   *
-   * @internal
-   */
-  path: string[]
-}
-
-export function createGeneralHooks<
-  TInputSchema extends Schema = undefined,
-  TOutputSchema extends Schema = undefined,
-  TFuncOutput extends
-  SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>,
->(
-  options: CreateGeneralHooksOptions,
-): GeneralHooks<TInputSchema, TOutputSchema, TFuncOutput> {
-  return {
-    useIsFetching(filters) {
-      const { queryType, input, ...rest } = filters ?? {}
-      const context = useORPCContext(options.context)
-      return useIsFetching(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: queryType,
-          }),
-          ...rest,
-        },
-        context.queryClient,
-      )
-    },
-    useIsMutating(filters) {
-      const context = useORPCContext(options.context)
-      return useIsMutating(
-        { mutationKey: getMutationKeyFromPath(options.path), ...filters },
-        context.queryClient,
-      )
-    },
-
-    useMutationState(options_) {
-      const context = useORPCContext(options.context)
-      return useMutationState(
-        {
-          ...(options_ as any),
-          filters: {
-            mutationKey: getMutationKeyFromPath(options.path),
-            ...options_?.filters,
-          },
-        },
-        context.queryClient,
-      )
-    },
-  }
-}