@orpc/react 0.0.4 → 0.0.6

package/src/react-utils.ts

@@ -5,32 +5,21 @@ import type {
   SchemaOutput,
 } from '@orpc/contract'
 import type { Procedure, Router } from '@orpc/server'
-import { type GeneralUtils, createGeneralUtils } from './general-utils'
-import { type ProcedureUtils, createProcedureUtils } from './procedure-utils'
 import type { ORPCContextValue } from './react-context'
+import { createGeneralUtils, type GeneralUtils } from './general-utils'
+import { createProcedureUtils, type ProcedureUtils } from './procedure-utils'
 
 export type ORPCUtilsWithContractRouter<TRouter extends ContractRouter> = {
-  [K in keyof TRouter]: TRouter[K] extends ContractProcedure<
-    infer UInputSchema,
-    infer UOutputSchema
-  >
-    ? ProcedureUtils<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>> &
-        GeneralUtils<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>>
+  [K in keyof TRouter]: TRouter[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema>
+    ? ProcedureUtils<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>> & GeneralUtils<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>>
     : TRouter[K] extends ContractRouter
       ? ORPCUtilsWithContractRouter<TRouter[K]>
       : never
 } & GeneralUtils<undefined, undefined, unknown>
 
 export type ORPCUtilsWithRouter<TRouter extends Router<any>> = {
-  [K in keyof TRouter]: TRouter[K] extends Procedure<
-    any,
-    any,
-    infer UInputSchema,
-    infer UOutputSchema,
-    infer UHandlerOutput
-  >
-    ? ProcedureUtils<UInputSchema, UOutputSchema, UHandlerOutput> &
-        GeneralUtils<UInputSchema, UOutputSchema, UHandlerOutput>
+  [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>
+    ? ProcedureUtils<UInputSchema, UOutputSchema, UFuncOutput> & GeneralUtils<UInputSchema, UOutputSchema, UFuncOutput>
     : TRouter[K] extends Router<any>
       ? ORPCUtilsWithRouter<TRouter[K]>
       : never
@@ -52,10 +41,10 @@ export interface CreateORPCUtilsOptions<
 export function createORPCUtils<TRouter extends ContractRouter | Router<any>>(
   options: CreateORPCUtilsOptions<TRouter>,
 ): TRouter extends Router<any>
-  ? ORPCUtilsWithRouter<TRouter>
-  : TRouter extends ContractRouter
-    ? ORPCUtilsWithContractRouter<TRouter>
-    : never {
+    ? ORPCUtilsWithRouter<TRouter>
+    : TRouter extends ContractRouter
+      ? ORPCUtilsWithContractRouter<TRouter>
+      : never {
   const path = options.path ?? []
   const client = options.contextValue.client as any
 
@@ -67,10 +56,10 @@ export function createORPCUtils<TRouter extends ContractRouter | Router<any>>(
   // for sure root is not procedure, so do not it procedure utils on root
   const procedureUtils = path.length
     ? createProcedureUtils({
-        client,
-        queryClient: options.contextValue.queryClient,
-        path,
-      })
+      client,
+      queryClient: options.contextValue.queryClient,
+      path,
+    })
     : {}
 
   return new Proxy(

package/src/react.test-d.ts

@@ -1,16 +1,16 @@
 import type { SchemaOutput } from '@orpc/contract'
 import type { QueryClient } from '@tanstack/react-query'
+import type { GeneralHooks } from './general-hooks'
+import type { GeneralUtils } from './general-utils'
+import type { ProcedureHooks } from './procedure-hooks'
+import type { ProcedureUtils } from './procedure-utils'
 import {
+  orpc,
+  orpcClient,
   ORPCContext,
   type UserFindInputSchema,
   type UserSchema,
-  orpc,
-  orpcClient,
 } from '../tests/orpc'
-import type { GeneralHooks } from './general-hooks'
-import type { GeneralUtils } from './general-utils'
-import type { ProcedureHooks } from './procedure-hooks'
-import type { ProcedureUtils } from './procedure-utils'
 import { useQueriesFactory } from './use-queries/hook'
 
 describe('useUtils', () => {

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,25 +1,25 @@
 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> =
@@ -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,
@@ -26,23 +25,23 @@ type UseQueryOptionsForUseQueries<
 export interface UseQueriesBuilder<
   TInputSchema extends Schema,
   TOutputSchema extends Schema,
-  THandlerOutput extends SchemaOutput<TOutputSchema>,
+  TFuncOutput extends SchemaOutput<TOutputSchema>,
 > {
   (
     input: SchemaInput<TInputSchema>,
     options?: SetOptional<
-      UseQueryOptionsForUseQueries<SchemaOutput<TOutputSchema, THandlerOutput>>,
+      UseQueryOptionsForUseQueries<SchemaOutput<TOutputSchema, TFuncOutput>>,
       'queryFn' | 'queryKey'
     >,
-  ): UseQueryOptionsForUseQueries<SchemaOutput<TOutputSchema, THandlerOutput>>
+  ): UseQueryOptionsForUseQueries<SchemaOutput<TOutputSchema, TFuncOutput>>
 }
 
 export interface CreateUseQueriesBuilderOptions<
   TInputSchema extends Schema,
   TOutputSchema extends Schema,
-  THandlerOutput extends SchemaOutput<TOutputSchema>,
+  TFuncOutput extends SchemaOutput<TOutputSchema>,
 > {
-  client: ProcedureClient<TInputSchema, TOutputSchema, THandlerOutput>
+  client: ProcedureClient<TInputSchema, TOutputSchema, TFuncOutput>
 
   /**
    * The path of procedure on server
@@ -53,15 +52,15 @@ export interface CreateUseQueriesBuilderOptions<
 export function createUseQueriesBuilder<
   TInputSchema extends Schema = undefined,
   TOutputSchema extends Schema = undefined,
-  THandlerOutput extends
-    SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>,
+  TFuncOutput extends
+  SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>,
 >(
   options: CreateUseQueriesBuilderOptions<
     TInputSchema,
     TOutputSchema,
-    THandlerOutput
+    TFuncOutput
   >,
-): UseQueriesBuilder<TInputSchema, TOutputSchema, THandlerOutput> {
+): UseQueriesBuilder<TInputSchema, TOutputSchema, TFuncOutput> {
   return (input, options_) => {
     return {
       queryKey: getQueryKeyFromPath(options.path, { input, type: 'query' }),

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
@@ -34,9 +34,9 @@ export type UseQueriesBuildersWithRouter<TRouter extends Router<any>> = {
     any,
     infer UInputSchema,
     infer UOutputSchema,
-    infer UHandlerOutput
+    infer UFuncOutput
   >
-    ? UseQueriesBuilder<UInputSchema, UOutputSchema, UHandlerOutput>
+    ? UseQueriesBuilder<UInputSchema, UOutputSchema, UFuncOutput>
     : TRouter[K] extends Router<any>
       ? UseQueriesBuildersWithRouter<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
 }