@orpc/react 0.0.3 → 0.0.5

package/src/react.test.tsx

@@ -6,7 +6,7 @@ beforeEach(() => {
 })
 
 it('useUtils', async () => {
-  const { result } = renderHook(() => orpc.useUtils(), { wrapper: wrapper })
+  const { result } = renderHook(() => orpc.useUtils(), { wrapper })
 
   const promise = result.current.user.find.ensureQueryData({ id: '1' })
   expect(result.current.user.isFetching()).toBe(1)
@@ -26,7 +26,7 @@ it('useUtils', async () => {
 })
 
 it('useContext', async () => {
-  const { result } = renderHook(() => orpc.useContext(), { wrapper: wrapper })
+  const { result } = renderHook(() => orpc.useContext(), { wrapper })
 
   expect(result.current.client).toBe(orpcClient)
   expect(result.current.queryClient).toBe(queryClient)
@@ -38,8 +38,8 @@ it('useContext', async () => {
 
 it('useQueries', async () => {
   const queries = renderHook(
-    () => orpc.useQueries((o) => [o.user.find({ id: '123' })]),
-    { wrapper: wrapper },
+    () => orpc.useQueries(o => [o.user.find({ id: '123' })]),
+    { wrapper },
   )
 
   await waitFor(() =>
@@ -52,20 +52,20 @@ it('useQueries', async () => {
 
 it('hooks', async () => {
   const isFetching = renderHook(() => orpc.user.useIsFetching(), {
-    wrapper: wrapper,
+    wrapper,
   })
   const isMutating = renderHook(() => orpc.user.useIsMutating(), {
-    wrapper: wrapper,
+    wrapper,
   })
 
   expect(isFetching.result.current).toBe(0)
   expect(isMutating.result.current).toBe(0)
 
   const query = renderHook(() => orpc.user.find.useQuery({ id: '1' }), {
-    wrapper: wrapper,
+    wrapper,
   })
   const mutation = renderHook(() => orpc.user.create.useMutation(), {
-    wrapper: wrapper,
+    wrapper,
   })
 
   await waitFor(() => expect(query.result.current.status).toEqual('pending'))

package/src/react.tsx

@@ -1,32 +1,32 @@
 import type { ContractRouter } from '@orpc/contract'
 import type { Router } from '@orpc/server'
 import {
+  createORPCContext,
   type ORPCContext,
   type ORPCContextValue,
-  createORPCContext,
   useORPCContext,
 } from './react-context'
 import {
+  createORPCHooks,
   type ORPCHooksWithContractRouter,
   type ORPCHooksWithRouter,
-  createORPCHooks,
 } from './react-hooks'
 import {
+  createORPCUtils,
   type ORPCUtilsWithContractRouter,
   type ORPCUtilsWithRouter,
-  createORPCUtils,
 } from './react-utils'
 import {
+  useQueriesFactory,
   type UseQueriesWithContractRouter,
   type UseQueriesWithRouter,
-  useQueriesFactory,
 } from './use-queries/hook'
 
 export type ORPCReactWithContractRouter<TRouter extends ContractRouter> =
   ORPCHooksWithContractRouter<TRouter> & {
     useContext: () => ORPCContextValue<TRouter>
     useUtils: () => ORPCUtilsWithContractRouter<TRouter>
-    useQueries: () => UseQueriesWithContractRouter<TRouter>
+    useQueries: UseQueriesWithContractRouter<TRouter>
   }
 
 export type ORPCReactWithRouter<TRouter extends Router<any>> =
@@ -49,6 +49,7 @@ export function createORPCReact<
   const Context = createORPCContext<TRouter>()
   const useContext = () => useORPCContext(Context)
   const useUtils = () => createORPCUtils({ contextValue: useContext() })
+  // eslint-disable-next-line react-hooks/rules-of-hooks
   const useQueries = useQueriesFactory({ context: Context })
   const hooks = createORPCHooks({ context: Context })
 

package/src/tanstack-key.ts

@@ -1,12 +1,12 @@
 import type { SchemaInput } from '@orpc/contract'
 import type { PartialDeep } from '@orpc/shared'
 import type { MutationKey, QueryKey } from '@tanstack/react-query'
-import { getORPCPath } from './orpc-path'
 import type { ProcedureHooks } from './procedure-hooks'
 import type {
   ORPCHooksWithContractRouter,
   ORPCHooksWithRouter,
 } from './react-hooks'
+import { getORPCPath } from './orpc-path'
 
 export type QueryType = 'query' | 'infinite' | undefined
 
@@ -17,9 +17,9 @@ export interface GetQueryKeyOptions<TInput> {
 
 export function getQueryKey<
   T extends
-    | ORPCHooksWithContractRouter<any>
-    | ORPCHooksWithRouter<any>
-    | ProcedureHooks<any, any, any>,
+  | ORPCHooksWithContractRouter<any>
+  | ORPCHooksWithRouter<any>
+  | ProcedureHooks<any, any, any>,
 >(
   orpc: T,
   options?: GetQueryKeyOptions<
@@ -36,8 +36,8 @@ export function getQueryKeyFromPath(
   path: string[],
   options?: GetQueryKeyOptions<unknown>,
 ): QueryKey {
-  const withInput =
-    options?.input !== undefined ? { input: options?.input } : {}
+  const withInput
+    = options?.input !== undefined ? { input: options?.input } : {}
   const withType = options?.type !== undefined ? { type: options?.type } : {}
 
   return [
@@ -51,9 +51,9 @@ export function getQueryKeyFromPath(
 
 export function getMutationKey<
   T extends
-    | ORPCHooksWithContractRouter<any>
-    | ORPCHooksWithRouter<any>
-    | ProcedureHooks<any, any, any>,
+  | ORPCHooksWithContractRouter<any>
+  | ORPCHooksWithRouter<any>
+  | ProcedureHooks<any, any, any>,
 >(orpc: T): MutationKey {
   const path = getORPCPath(orpc)
   return getMutationKeyFromPath(path)

package/src/tanstack-query.ts

@@ -20,8 +20,8 @@ export interface ORPCAdditionalQueryFilters<TFilterInput> {
 
 export interface ORPCQueryFilters<TFilterInput>
   extends SetOptional<QueryFilters, 'queryKey'>,
-    ORPCAdditionalQueryFilters<TFilterInput> {}
+  ORPCAdditionalQueryFilters<TFilterInput> {}
 
 export interface ORPCInvalidateQueryFilters<TFilterInput>
   extends SetOptional<InvalidateQueryFilters, 'queryKey'>,
-    ORPCAdditionalQueryFilters<TFilterInput> {}
+  ORPCAdditionalQueryFilters<TFilterInput> {}

package/src/types.ts

@@ -4,4 +4,4 @@ export type SchemaInputForInfiniteQuery<TInputSchema extends Schema> = Omit<
   SchemaInput<TInputSchema>,
   'cursor'
 > &
-  (Record<string | number, any> & { cursor?: never })
+(Record<string | number, any> & { cursor?: never })

package/src/use-queries/builder.test-d.ts

@@ -1,4 +1,4 @@
-import type { Promisable } from '@orpc/server'
+import type { Promisable } from '@orpc/shared'
 import { orpcClient } from '../../tests/orpc'
 import { createUseQueriesBuilder } from './builder'
 
@@ -19,7 +19,7 @@ it('createUseQueriesBuilder', () => {
   builder({ id: 123 })
 
   if (typeof result.queryFn === 'function') {
-    expectTypeOf(result.queryFn({} as any)).toEqualTypeOf<
+    expectTypeOf(result.queryFn({} as any)).toMatchTypeOf<
       Promisable<{
         id: string
         name: string

package/src/use-queries/builder.ts

@@ -1,6 +1,5 @@
 import type { ProcedureClient } from '@orpc/client'
 import type { Schema, SchemaInput, SchemaOutput } from '@orpc/contract'
-import type {} from '@orpc/server'
 import type { SetOptional } from '@orpc/shared'
 import type {
   DefaultError,
@@ -54,7 +53,7 @@ export function createUseQueriesBuilder<
   TInputSchema extends Schema = undefined,
   TOutputSchema extends Schema = undefined,
   THandlerOutput extends
-    SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>,
+  SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>,
 >(
   options: CreateUseQueriesBuilderOptions<
     TInputSchema,

package/src/use-queries/builders.ts

@@ -9,7 +9,7 @@ import type {
 } from '@orpc/contract'
 import type { Procedure, Router } from '@orpc/server'
 import type {} from '@tanstack/react-query'
-import { type UseQueriesBuilder, createUseQueriesBuilder } from './builder'
+import { createUseQueriesBuilder, type UseQueriesBuilder } from './builder'
 
 export type UseQueriesBuildersWithContractRouter<
   TRouter extends ContractRouter,
@@ -19,10 +19,10 @@ export type UseQueriesBuildersWithContractRouter<
     infer UOutputSchema
   >
     ? UseQueriesBuilder<
-        UInputSchema,
-        UOutputSchema,
-        SchemaOutput<UOutputSchema>
-      >
+      UInputSchema,
+      UOutputSchema,
+      SchemaOutput<UOutputSchema>
+    >
     : TRouter[K] extends ContractRouter
       ? UseQueriesBuildersWithContractRouter<TRouter[K]>
       : never
@@ -62,10 +62,10 @@ export function createUseQueriesBuilders<
 >(
   options: CreateUseQueriesBuildersOptions<TRouter>,
 ): TRouter extends Router<any>
-  ? UseQueriesBuildersWithRouter<TRouter>
-  : TRouter extends ContractRouter
-    ? UseQueriesBuildersWithContractRouter<TRouter>
-    : never {
+    ? UseQueriesBuildersWithRouter<TRouter>
+    : TRouter extends ContractRouter
+      ? UseQueriesBuildersWithContractRouter<TRouter>
+      : never {
   const path = options.path ?? []
   const client = options.client as any
 

package/src/use-queries/hook.test-d.ts

@@ -1,9 +1,9 @@
 import type { SchemaOutput } from '@orpc/contract'
 import {
+  orpcClient,
   ORPCContext,
   type UserListOutputSchema,
   type UserSchema,
-  orpcClient,
 } from '../../tests/orpc'
 import { createUseQueriesBuilders } from './builders'
 import { useQueriesFactory } from './hook'

package/src/use-queries/hook.test.tsx

@@ -1,5 +1,5 @@
 import { renderHook, waitFor } from '@testing-library/react'
-import { ORPCContext, orpcClient, wrapper } from '../../tests/orpc'
+import { orpcClient, ORPCContext, wrapper } from '../../tests/orpc'
 import { createUseQueriesBuilders } from './builders'
 import { useQueriesFactory } from './hook'
 
@@ -18,7 +18,7 @@ describe('useQueriesFactory', () => {
 
           return [o.user.find({ id: '123' }), o.user.list({})]
         }),
-      { wrapper: wrapper },
+      { wrapper },
     )
 
     await waitFor(() =>

package/src/use-queries/hook.ts

@@ -7,9 +7,9 @@ import {
 } from '@tanstack/react-query'
 import { type ORPCContext, useORPCContext } from '../react-context'
 import {
+  createUseQueriesBuilders,
   type UseQueriesBuildersWithContractRouter,
   type UseQueriesBuildersWithRouter,
-  createUseQueriesBuilders,
 } from './builders'
 
 export interface UseQueriesWithContractRouter<TRouter extends ContractRouter> {
@@ -39,19 +39,19 @@ export interface UseQueriesFactoryOptions<
 export function useQueriesFactory<TRouter extends Router<any> | ContractRouter>(
   options: UseQueriesFactoryOptions<TRouter>,
 ): TRouter extends Router<any>
-  ? UseQueriesWithRouter<TRouter>
-  : TRouter extends ContractRouter
-    ? UseQueriesWithContractRouter<TRouter>
-    : never {
-  const hook = (build: any, combine?: any) => {
+    ? UseQueriesWithRouter<TRouter>
+    : TRouter extends ContractRouter
+      ? UseQueriesWithContractRouter<TRouter>
+      : never {
+  const Hook = (build: any, combine?: any): any => {
     const orpc = useORPCContext(options.context)
     const builders = createUseQueriesBuilders({ client: orpc.client as any })
 
     return useQueries({
       queries: build(builders),
-      combine: combine,
+      combine,
     })
   }
 
-  return hook as any
+  return Hook as any
 }