@orpc/react 0.10.0-beta.1 → 0.11.0

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,
-      )
-    },
-  }
-}

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

@@ -1,454 +0,0 @@
-import type { SchemaOutput } from '@orpc/contract'
-import type { Promisable } from '@orpc/shared'
-import type { InfiniteData } from '@tanstack/react-query'
-import {
-  queryClient,
-  type UserCreateInputSchema,
-  type UserFindInputSchema,
-  type UserListInputSchema,
-  type UserListOutputSchema,
-  type UserSchema,
-} from '../tests/orpc'
-import { createGeneralUtils } from './general-utils'
-
-const user_utils = createGeneralUtils({
-  queryClient,
-  path: ['user'],
-})
-
-const user_find_utils = createGeneralUtils<
-  typeof UserFindInputSchema,
-  typeof UserSchema,
-  SchemaOutput<typeof UserSchema>
->({
-  queryClient,
-  path: ['user', 'find'],
-})
-
-const user_list_utils = createGeneralUtils<
-  typeof UserListInputSchema,
-  typeof UserListOutputSchema,
-  SchemaOutput<typeof UserListOutputSchema>
->({
-  queryClient,
-  path: ['user', 'list'],
-})
-
-const user_create_utils = createGeneralUtils<
-  typeof UserCreateInputSchema,
-  typeof UserSchema,
-  SchemaOutput<typeof UserSchema>
->({
-  queryClient,
-  path: ['user', 'create'],
-})
-
-describe('getQueriesData', () => {
-  it('simple', () => {
-    expectTypeOf(user_utils.getQueriesData()).toMatchTypeOf(
-      queryClient.getQueriesData<unknown>({}),
-    )
-
-    expectTypeOf(user_find_utils.getQueriesData()).toMatchTypeOf(
-      queryClient.getQueriesData<SchemaOutput<typeof UserSchema>>({}),
-    )
-  })
-
-  it('with filters', () => {
-    user_find_utils.getQueriesData({ input: { id: '1' } })
-    // @ts-expect-error invalid input
-    user_find_utils.getQueriesData({ input: { id: 1 } })
-  })
-})
-
-describe('getInfiniteQueriesData', () => {
-  it('simple', () => {
-    expectTypeOf(user_utils.getInfiniteQueriesData()).toMatchTypeOf(
-      queryClient.getQueriesData<InfiniteData<unknown>>({}),
-    )
-
-    expectTypeOf(user_list_utils.getInfiniteQueriesData()).toMatchTypeOf(
-      queryClient.getQueriesData<
-        InfiniteData<SchemaOutput<typeof UserListOutputSchema>>
-      >({}),
-    )
-  })
-
-  it('with filters', () => {
-    user_list_utils.getQueriesData({ input: { keyword: '1' } })
-    // @ts-expect-error invalid input
-    user_list_utils.getQueriesData({ input: { keyword: 1 } })
-  })
-})
-
-describe('setQueriesData', () => {
-  it('simple', () => {
-    user_utils.setQueriesData({}, (old: unknown) => {
-      expectTypeOf(old).toMatchTypeOf<unknown | undefined>()
-
-      return 'can return any value'
-    })
-
-    user_find_utils.setQueriesData({}, (old) => {
-      expectTypeOf(old).toEqualTypeOf<
-        SchemaOutput<typeof UserSchema> | undefined
-      >()
-
-      return old
-    })
-  })
-
-  it('with filters', () => {
-    user_find_utils.setQueriesData({ input: { id: '1' } }, undefined, {
-      updatedAt: 12344,
-    })
-    // @ts-expect-error invalid input
-    user_find_utils.setQueriesData({ input: { id: 1 } }, undefined)
-  })
-})
-
-describe('setInfiniteQueriesData', () => {
-  it('simple', () => {
-    user_utils.setInfiniteQueriesData({}, (old) => {
-      expectTypeOf(old).toEqualTypeOf<InfiniteData<unknown> | undefined>()
-
-      return {
-        pageParams: [],
-        pages: [],
-      }
-    })
-
-    user_list_utils.setInfiniteQueriesData({}, (old) => {
-      expectTypeOf(old).toEqualTypeOf<
-        | InfiniteData<
-          SchemaOutput<typeof UserListOutputSchema>,
-            number | undefined
-        >
-        | undefined
-      >()
-
-      return old
-    })
-  })
-
-  it('with filters', () => {
-    user_list_utils.setInfiniteQueriesData(
-      { input: { keyword: '1' } },
-      undefined,
-      {
-        updatedAt: 12344,
-      },
-    )
-    // @ts-expect-error invalid input
-    user_list_utils.setInfiniteQueriesData({ input: { keyword: 1 } }, undefined)
-  })
-})
-
-it('invalidate', () => {
-  user_utils.invalidate()
-  user_utils.invalidate({
-    input: 'anything',
-  })
-  user_utils.invalidate({
-    queryType: 'infinite' /** only invalidate infinite */,
-  })
-
-  user_find_utils.invalidate({
-    input: { id: '12' },
-  })
-  user_find_utils.invalidate({
-    // @ts-expect-error invalid input
-    input: { id: 12 },
-  })
-
-  const result = user_find_utils.invalidate({}, { throwOnError: true })
-
-  expectTypeOf(result).toEqualTypeOf<Promise<void>>()
-})
-
-it('refetch', () => {
-  user_utils.refetch()
-  user_utils.refetch({
-    input: 'anything',
-  })
-  user_utils.refetch({
-    queryType: 'infinite' /** only refetch infinite */,
-  })
-
-  user_find_utils.refetch({
-    input: { id: '12' },
-  })
-  user_find_utils.refetch({
-    // @ts-expect-error invalid input
-    input: { id: 12 },
-  })
-
-  const result = user_find_utils.refetch({}, { throwOnError: true })
-
-  expectTypeOf(result).toEqualTypeOf<Promise<void>>()
-})
-
-it('cancel', () => {
-  user_utils.cancel()
-  user_utils.cancel({
-    input: 'anything',
-  })
-  user_utils.cancel({
-    queryType: 'infinite' /** only cancel infinite */,
-  })
-
-  user_find_utils.cancel({
-    input: { id: '12' },
-  })
-  user_find_utils.cancel({
-    // @ts-expect-error invalid input
-    input: { id: 12 },
-  })
-
-  const result = user_find_utils.cancel({}, { revert: true })
-
-  expectTypeOf(result).toEqualTypeOf<Promise<void>>()
-})
-
-it('remove', () => {
-  user_utils.remove()
-  user_utils.remove({
-    input: 'anything',
-  })
-  user_utils.remove({
-    queryType: 'infinite' /** only remove infinite */,
-  })
-
-  user_find_utils.remove({
-    input: { id: '12' },
-  })
-  user_find_utils.remove({
-    // @ts-expect-error invalid input
-    input: { id: 12 },
-  })
-
-  const result = user_find_utils.remove({})
-
-  expectTypeOf(result).toEqualTypeOf<void>()
-})
-
-it('reset', () => {
-  user_utils.reset()
-  user_utils.reset({
-    input: 'anything',
-  })
-  user_utils.reset({
-    queryType: 'infinite' /** only reset infinite */,
-  })
-
-  user_find_utils.reset({
-    input: { id: '12' },
-  })
-  user_find_utils.reset({
-    // @ts-expect-error invalid input
-    input: { id: 12 },
-  })
-
-  const result = user_find_utils.reset({}, { throwOnError: true })
-
-  expectTypeOf(result).toEqualTypeOf<Promise<void>>()
-})
-
-it('isFetching', () => {
-  user_utils.isFetching()
-  user_utils.isFetching({
-    input: 'anything',
-  })
-  user_utils.isFetching({
-    queryType: 'infinite' /** only isFetching infinite */,
-  })
-
-  user_find_utils.isFetching({
-    input: { id: '12' },
-  })
-  user_find_utils.isFetching({
-    // @ts-expect-error invalid input
-    input: { id: 12 },
-  })
-
-  const result = user_find_utils.isFetching({})
-
-  expectTypeOf(result).toEqualTypeOf<number>()
-})
-
-it('isMutating', () => {
-  user_utils.isMutating()
-
-  const result = user_find_utils.isMutating({})
-
-  expectTypeOf(result).toEqualTypeOf<number>()
-})
-
-it('getQueryDefaults', () => {
-  const r1 = user_utils.getQueryDefaults()
-
-  if (typeof r1.queryFn === 'function') {
-    expectTypeOf<ReturnType<typeof r1.queryFn>>().toMatchTypeOf<
-      Promisable<unknown>
-    >()
-  }
-
-  user_utils.getQueryDefaults({
-    input: 'anything',
-  })
-
-  user_find_utils.getQueryDefaults({
-    input: { id: '12' },
-  })
-  user_find_utils.getQueryDefaults({
-    // @ts-expect-error invalid input
-    input: { id: 12 },
-  })
-
-  const r2 = user_find_utils.getQueryDefaults({})
-
-  if (typeof r2.queryFn === 'function') {
-    expectTypeOf<ReturnType<typeof r2.queryFn>>().toMatchTypeOf<
-      Promisable<SchemaOutput<typeof UserSchema>>
-    >()
-  }
-})
-
-it('getInfiniteQueryDefaults', () => {
-  const r1 = user_utils.getInfiniteQueryDefaults()
-  if (typeof r1.queryFn === 'function') {
-    expectTypeOf<ReturnType<typeof r1.queryFn>>().toMatchTypeOf<
-      Promisable<unknown>
-    >()
-  }
-
-  user_utils.getInfiniteQueryDefaults({
-    input: {},
-  })
-
-  user_find_utils.getInfiniteQueryDefaults({
-    input: { id: '12' },
-  })
-  user_find_utils.getInfiniteQueryDefaults({
-    // @ts-expect-error invalid input
-    input: { id: 12 },
-  })
-
-  const r2 = user_find_utils.getInfiniteQueryDefaults({})
-
-  if (typeof r2.queryFn === 'function') {
-    expectTypeOf<ReturnType<typeof r2.queryFn>>().toMatchTypeOf<
-      Promisable<SchemaOutput<typeof UserSchema>>
-    >()
-  }
-})
-
-it('setQueryDefaults', () => {
-  user_utils.setQueryDefaults({
-    queryFn() {
-      return 'anything'
-    },
-    enabled(query) {
-      expectTypeOf(query.state.data).toEqualTypeOf<unknown>()
-
-      return true
-    },
-  })
-
-  user_utils.setQueryDefaults(
-    {},
-    {
-      input: 'anything',
-    },
-  )
-
-  user_find_utils.setQueryDefaults(
-    {},
-    {
-      input: { id: '12' },
-    },
-  )
-  user_find_utils.setQueryDefaults(
-    {},
-    {
-      // @ts-expect-error invalid input
-      input: { id: 12 },
-    },
-  )
-
-  user_find_utils.setQueryDefaults({
-    queryFn() {
-      return { id: '1233', name: 'name' }
-    },
-    enabled(query) {
-      expectTypeOf(query.state.data).toEqualTypeOf<
-        SchemaOutput<typeof UserSchema> | undefined
-      >()
-
-      return true
-    },
-  })
-
-  user_find_utils.setQueryDefaults({
-    // @ts-expect-error invalid
-    queryFn() {
-      return 'invalid'
-    },
-  })
-})
-
-it('setInfiniteQueryDefaults', () => {
-  user_utils.setInfiniteQueryDefaults({
-    queryFn() {
-      return 'anything'
-    },
-    enabled(query) {
-      expectTypeOf(query.state.data).toEqualTypeOf<
-        InfiniteData<unknown> | undefined
-      >()
-
-      return true
-    },
-  })
-
-  user_utils.setInfiniteQueryDefaults(
-    {},
-    {
-      input: 'anything',
-    },
-  )
-
-  user_find_utils.setInfiniteQueryDefaults(
-    {},
-    {
-      input: { id: '12' },
-    },
-  )
-  user_find_utils.setInfiniteQueryDefaults(
-    {},
-    {
-      // @ts-expect-error invalid input
-      input: { id: 12 },
-    },
-  )
-
-  user_find_utils.setInfiniteQueryDefaults({
-    queryFn() {
-      return { id: '1233', name: 'name' }
-    },
-    enabled(query) {
-      expectTypeOf(query.state.data).toEqualTypeOf<
-        InfiniteData<SchemaOutput<typeof UserSchema>> | undefined
-      >()
-
-      return true
-    },
-  })
-
-  user_find_utils.setInfiniteQueryDefaults({
-    // @ts-expect-error invalid
-    queryFn() {
-      return 'invalid'
-    },
-  })
-})