@graphql-suite/query 0.8.3 → 0.9.1

package/README.md

@@ -1,191 +1,299 @@
-[![Monthly Downloads](https://img.shields.io/npm/dm/drizzle-graphql-suite.svg)](https://www.npmjs.com/package/drizzle-graphql-suite)
-[![NPM](https://img.shields.io/npm/v/drizzle-graphql-suite.svg 'NPM package version')](https://www.npmjs.com/package/drizzle-graphql-suite)
-[![CI](https://github.com/annexare/drizzle-graphql-suite/actions/workflows/ci.yml/badge.svg)](https://github.com/annexare/drizzle-graphql-suite/actions/workflows/ci.yml)
+# @graphql-suite/query
 
-# drizzle-graphql-suite
+> Part of [`graphql-suite`](https://github.com/annexare/graphql-suite).
+> See also: [`schema`](https://github.com/annexare/graphql-suite/tree/main/packages/schema) | [`client`](https://github.com/annexare/graphql-suite/tree/main/packages/client)
 
-Auto-generated GraphQL CRUD, type-safe clients, and React Query hooks from Drizzle PostgreSQL schemas.
+TanStack React Query hooks for `@graphql-suite/client` — type-safe data fetching with caching, pagination, and mutations.
 
-## Overview
-
-`drizzle-graphql-suite` is a three-layer toolkit that turns your Drizzle ORM schema into a fully working GraphQL API with end-to-end type safety:
-
-1. **Schema builder** — generates a complete GraphQL schema with CRUD operations, relation-level filtering, per-operation hooks, and runtime permissions from Drizzle table definitions.
-2. **Client** — provides a type-safe GraphQL client that infers query/mutation types directly from your Drizzle schema, with full TypeScript support for filters, relations, and results.
-3. **React Query hooks** — wraps the client in TanStack React Query hooks for caching, pagination, and mutations with automatic cache invalidation.
-
-Inspired by [`drizzle-graphql`](https://github.com/drizzle-team/drizzle-graphql), rewritten with significant improvements including relation-level filtering, hooks, count queries, configurable schema generation, and code generation.
+## Installation
 
-## Packages
+```bash
+bun add @graphql-suite/query
+```
 
-| Subpath | Package | Description |
-|---------|---------|-------------|
-| `drizzle-graphql-suite/schema` | [`@drizzle-graphql-suite/schema`](packages/schema/README.md) | GraphQL schema builder with CRUD, filtering, hooks, permissions, and codegen |
-| `drizzle-graphql-suite/client` | [`@drizzle-graphql-suite/client`](packages/client/README.md) | Type-safe GraphQL client with full Drizzle type inference |
-| `drizzle-graphql-suite/query` | [`@drizzle-graphql-suite/query`](packages/query/README.md) | TanStack React Query hooks for the client |
+```bash
+npm install @graphql-suite/query
+```
 
-## Installation
+Or install the full suite:
 
 ```bash
-bun add drizzle-graphql-suite
+bun add graphql-suite
 ```
 
 ```bash
-npm install drizzle-graphql-suite
+npm install graphql-suite
 ```
 
-## Peer Dependencies
+## Setup
+
+### Provider
+
+Wrap your app with `<GraphQLProvider>` inside a `<QueryClientProvider>`:
+
+```tsx
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { GraphQLProvider } from '@graphql-suite/query'
+import { client } from './graphql-client'
 
-Each subpath import has its own peer dependency requirements:
+const queryClient = new QueryClient()
 
-| Subpath | Peer Dependencies |
-|---------|-------------------|
-| `./schema` | `drizzle-orm` >=0.44.0, `graphql` >=16.3.0 |
-| `./client` | `drizzle-orm` >=0.44.0 |
-| `./query` | `react` >=18.0.0, `@tanstack/react-query` >=5.0.0 |
+function App() {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <GraphQLProvider client={client}>
+        {/* your app */}
+      </GraphQLProvider>
+    </QueryClientProvider>
+  )
+}
+```
 
-## Quick Start
+### `useGraphQLClient()`
 
-### 1. Server — Build GraphQL Schema
+Access the raw `GraphQLClient` instance from context:
 
 ```ts
-import { buildSchema } from 'drizzle-graphql-suite/schema'
-import { createYoga } from 'graphql-yoga'
-import { createServer } from 'node:http'
-import { db } from './db'
-
-const { schema, withPermissions } = buildSchema(db, {
-  tables: { exclude: ['session', 'verification'] },
-  hooks: {
-    user: {
-      query: {
-        before: async ({ context }) => {
-          if (!context.user) throw new Error('Unauthorized')
-        },
-      },
-    },
-  },
-})
+import { useGraphQLClient } from '@graphql-suite/query'
 
-const yoga = createYoga({ schema })
-const server = createServer(yoga)
-server.listen(4000)
+function MyComponent() {
+  const client = useGraphQLClient()
+  // client.entity('user'), client.execute(query, variables), etc.
+}
 ```
 
-#### Per-Role Schemas (Optional)
+### `useEntity(entityName)`
+
+Get a typed `EntityClient` for use with query and mutation hooks:
 
 ```ts
-import { permissive, restricted, readOnly } from 'drizzle-graphql-suite/schema'
+import { useEntity } from '@graphql-suite/query'
 
-// Cached per id — call withPermissions on each request
-const schemas = {
-  admin: schema,
-  editor: withPermissions(permissive('editor', { audit: false, user: readOnly() })),
-  viewer: withPermissions(restricted('viewer', { post: { query: true } })),
+function UserList() {
+  const user = useEntity('user')
+  // Pass `user` to useEntityList, useEntityQuery, etc.
 }
 ```
 
-### 2. Client — Type-Safe Queries
+## Query Hooks
 
-```ts
-import { createDrizzleClient } from 'drizzle-graphql-suite/client'
-import * as schema from './db/schema'
+### `useEntityList(entity, params, options?)`
 
-const client = createDrizzleClient({
-  schema,
-  config: { suffixes: { list: 's' } },
-  url: '/api/graphql',
-})
+Fetch a list of records. Returns `UseQueryResult<T[]>`.
 
-const users = await client.entity('user').query({
-  select: {
-    id: true,
-    name: true,
-    posts: { id: true, title: true },
-  },
-  where: { name: { ilike: '%john%' } },
-  limit: 10,
-})
+**Params**: `select`, `where`, `limit`, `offset`, `orderBy`
+
+```tsx
+import { useEntity, useEntityList } from '@graphql-suite/query'
+
+function UserList() {
+  const user = useEntity('user')
+  const { data, isLoading, error } = useEntityList(user, {
+    select: { id: true, name: true, email: true },
+    where: { role: { eq: 'admin' } },
+    orderBy: { name: { direction: 'asc', priority: 1 } },
+    limit: 20,
+  })
+
+  if (isLoading) return <div>Loading...</div>
+  if (error) return <div>Error: {error.message}</div>
+
+  return (
+    <ul>
+      {data?.map((u) => <li key={u.id}>{u.name} ({u.email})</li>)}
+    </ul>
+  )
+}
 ```
 
-### 3. React — Query Hooks
+### `useEntityQuery(entity, params, options?)`
+
+Fetch a single record. Returns `UseQueryResult<T | null>`.
+
+**Params**: `select`, `where`, `offset`, `orderBy`
 
 ```tsx
-import { GraphQLProvider, useEntity, useEntityList } from 'drizzle-graphql-suite/query'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+function UserDetail({ userId }: { userId: string }) {
+  const user = useEntity('user')
+  const { data } = useEntityQuery(user, {
+    select: { id: true, name: true, email: true, role: true },
+    where: { id: { eq: userId } },
+  })
 
-const queryClient = new QueryClient()
+  if (!data) return null
+  return <div>{data.name} — {data.role}</div>
+}
+```
+
+### `useEntityInfiniteQuery(entity, params, options?)`
+
+Infinite scrolling with cursor-based pagination. Returns `UseInfiniteQueryResult` with pages containing `{ items: T[], count: number }`.
+
+**Params**: `select`, `where`, `pageSize`, `orderBy`
+
+```tsx
+function InfiniteUserList() {
+  const user = useEntity('user')
+  const { data, fetchNextPage, hasNextPage, isFetchingNextPage } =
+    useEntityInfiniteQuery(user, {
+      select: { id: true, name: true },
+      pageSize: 20,
+      orderBy: { name: { direction: 'asc', priority: 1 } },
+    })
+
+  const allUsers = data?.pages.flatMap((page) => page.items) ?? []
 
-function App() {
   return (
-    <QueryClientProvider client={queryClient}>
-      <GraphQLProvider client={graphqlClient}>
-        <UserList />
-      </GraphQLProvider>
-    </QueryClientProvider>
+    <div>
+      <ul>
+        {allUsers.map((u) => <li key={u.id}>{u.name}</li>)}
+      </ul>
+      {hasNextPage && (
+        <button onClick={() => fetchNextPage()} disabled={isFetchingNextPage}>
+          {isFetchingNextPage ? 'Loading...' : 'Load more'}
+        </button>
+      )}
+    </div>
   )
 }
+```
 
-function UserList() {
+### Query Options
+
+All query hooks accept an optional `options` parameter:
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `enabled` | `boolean` | Disable automatic fetching |
+| `gcTime` | `number` | Garbage collection time (ms) |
+| `staleTime` | `number` | Time until data is considered stale (ms) |
+| `refetchOnWindowFocus` | `boolean` | Refetch when window regains focus |
+| `queryKey` | `unknown[]` | Override the auto-generated query key |
+
+## Mutation Hooks
+
+### `useEntityInsert(entity, returning?, options?)`
+
+Insert records. Call `.mutate({ values })` to execute.
+
+```tsx
+function CreateUser() {
   const user = useEntity('user')
-  const { data, isLoading } = useEntityList(user, {
-    select: { id: true, name: true, email: true },
-    limit: 20,
-  })
+  const { mutate, isPending } = useEntityInsert(
+    user,
+    { id: true, name: true },
+    { onSuccess: (data) => console.log('Created:', data) },
+  )
 
-  if (isLoading) return <div>Loading...</div>
-  return <ul>{data?.map((u) => <li key={u.id}>{u.name}</li>)}</ul>
+  return (
+    <button
+      disabled={isPending}
+      onClick={() => mutate({
+        values: [{ name: 'Alice', email: 'alice@example.com' }],
+      })}
+    >
+      Create User
+    </button>
+  )
 }
 ```
 
-## Framework Integration Examples
+### `useEntityUpdate(entity, returning?, options?)`
 
-`buildSchema()` returns a standard `GraphQLSchema` — here's how to serve it from popular frameworks.
+Update records. Call `.mutate({ set, where })` to execute.
 
-### Next.js App Router
+```tsx
+function UpdateRole({ userId }: { userId: string }) {
+  const user = useEntity('user')
+  const { mutate } = useEntityUpdate(user, { id: true, role: true })
 
-```ts
-// app/api/graphql/route.ts
-import { createYoga } from 'graphql-yoga'
-import { buildSchema } from 'drizzle-graphql-suite/schema'
-import { db } from '@/db'
+  return (
+    <button onClick={() => mutate({
+      set: { role: 'admin' },
+      where: { id: { eq: userId } },
+    })}>
+      Make Admin
+    </button>
+  )
+}
+```
 
-const { schema } = buildSchema(db)
+### `useEntityDelete(entity, returning?, options?)`
 
-const { handleRequest } = createYoga({
-  schema,
-  graphqlEndpoint: '/api/graphql',
-  fetchAPI: { Response },
-})
+Delete records. Call `.mutate({ where })` to execute.
+
+```tsx
+function DeleteUser({ userId }: { userId: string }) {
+  const user = useEntity('user')
+  const { mutate } = useEntityDelete(user, { id: true })
 
-export { handleRequest as GET, handleRequest as POST }
+  return (
+    <button onClick={() => mutate({
+      where: { id: { eq: userId } },
+    })}>
+      Delete
+    </button>
+  )
+}
 ```
 
-### ElysiaJS
+### Mutation Options
+
+All mutation hooks accept an optional `options` parameter:
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `invalidate` | `boolean` | Invalidate queries after mutation (default: `true`) |
+| `invalidateKey` | `unknown[]` | Custom query key prefix to invalidate |
+| `onSuccess` | `(data) => void` | Callback after successful mutation |
+| `onError` | `(error) => void` | Callback after failed mutation |
+
+## Cache Invalidation
+
+By default, all mutations invalidate queries with the `['gql']` key prefix. Since all query hooks use keys starting with `['gql', ...]`, this means every mutation refreshes all GraphQL queries.
+
+### Custom Invalidation Key
+
+Narrow invalidation to specific queries:
 
 ```ts
-// server.ts
-import { Elysia } from 'elysia'
-import { yoga } from '@elysiajs/graphql-yoga'
-import { buildSchema } from 'drizzle-graphql-suite/schema'
-import { db } from './db'
+const { mutate } = useEntityUpdate(user, { id: true }, {
+  invalidateKey: ['gql', 'list'], // only invalidate list queries
+})
+```
 
-const { schema } = buildSchema(db)
+### Disable Invalidation
 
-new Elysia()
-  .use(yoga({ schema }))
-  .listen(3000)
+```ts
+const { mutate } = useEntityInsert(user, undefined, {
+  invalidate: false,
+})
 ```
 
-## AI Agent Skill
+### Query Key Override
 
-This repo includes a [skills.sh](https://skills.sh) skill that provides AI coding agents (Claude Code, Cursor, etc.) with accurate, up-to-date guidance for all three packages.
+Override the auto-generated key on query hooks for fine-grained cache control:
 
-```bash
-bunx skills add annexare/drizzle-graphql-suite
-# or: npx skills add annexare/drizzle-graphql-suite
+```ts
+const { data } = useEntityList(user, params, {
+  queryKey: ['users', 'admin-list'],
+})
 ```
 
-## License
+## Type Inference Flow
 
-MIT
+Types flow end-to-end from your Drizzle schema to hook return types:
+
+```
+Drizzle Schema (tables + relations)
+  ↓ InferEntityDefs
+EntityDefs (fields, filters, inputs, orderBy per table)
+  ↓ createDrizzleClient
+GraphQLClient<SchemaDescriptor, EntityDefs>
+  ↓ useEntity / client.entity()
+EntityClient<EntityDefs, EntityDef>
+  ↓ useEntityList / useEntityQuery (select param)
+InferResult<EntityDefs, EntityDef, Select>
+  ↓
+Fully typed data: only selected fields, relations resolve to T[] or T | null
+```

package/index.d.ts

@@ -1 +1,7 @@
-export * from '@drizzle-graphql-suite/query'
+export { GraphQLProvider, useGraphQLClient } from './provider';
+export type { GraphQLClientContext } from './types';
+export { useEntity } from './useEntity';
+export { useEntityInfiniteQuery } from './useEntityInfiniteQuery';
+export { useEntityList } from './useEntityList';
+export { useEntityDelete, useEntityInsert, useEntityUpdate } from './useEntityMutation';
+export { useEntityQuery } from './useEntityQuery';

package/index.js

@@ -1 +1,2 @@
-export * from '@drizzle-graphql-suite/query'
+/** @graphql-suite/query v0.9.1 | MIT */
+import{createContext as O,useContext as R}from"react";import{jsx as T}from"react/jsx-runtime";var H=O(null);function S({client:E,children:f}){return T(H.Provider,{value:E,children:f})}function B(){let E=R(H);if(!E)throw Error("useGraphQLClient must be used within a <GraphQLProvider>");return E}import{useMemo as V}from"react";function W(E){let f=B();return V(()=>f.entity(E),[f,E])}import{useInfiniteQuery as X}from"@tanstack/react-query";function Y(E,f,D){let U=D?.queryKey??["gql","infinite",f.select,f.where,f.orderBy,f.pageSize];return X({queryKey:U,initialPageParam:0,queryFn:async({pageParam:w=0})=>{let L={...f,limit:f.pageSize,offset:w*f.pageSize},z=await E.query(L),J=await E.count({where:f.where});return{items:z,count:J}},getNextPageParam:(w,L)=>{return L.length*f.pageSize<w.count?L.length:void 0},enabled:D?.enabled,gcTime:D?.gcTime,staleTime:D?.staleTime})}import{useQuery as Z}from"@tanstack/react-query";function _(E,f,D){let U=D?.queryKey??["gql","list",f.select,f.where,f.orderBy,f.limit,f.offset];return Z({queryKey:U,queryFn:async()=>{return await E.query(f)},enabled:D?.enabled,gcTime:D?.gcTime,staleTime:D?.staleTime,refetchOnWindowFocus:D?.refetchOnWindowFocus})}import{useMutation as F,useQueryClient as G}from"@tanstack/react-query";function $(E,f,D){let U=G(),w=D?.invalidate!==!1;return F({mutationFn:async(L)=>{return await E.insert({...L,returning:f})},onSuccess:(L)=>{if(w){let z=D?.invalidateKey??["gql"];U.invalidateQueries({queryKey:z})}D?.onSuccess?.(L)},onError:D?.onError})}function j(E,f,D){let U=G(),w=D?.invalidate!==!1;return F({mutationFn:async(L)=>{return await E.update({...L,returning:f})},onSuccess:(L)=>{if(w){let z=D?.invalidateKey??["gql"];U.invalidateQueries({queryKey:z})}D?.onSuccess?.(L)},onError:D?.onError})}function I(E,f,D){let U=G(),w=D?.invalidate!==!1;return F({mutationFn:async(L)=>{return await E.delete({...L,returning:f})},onSuccess:(L)=>{if(w){let z=D?.invalidateKey??["gql"];U.invalidateQueries({queryKey:z})}D?.onSuccess?.(L)},onError:D?.onError})}import{useQuery as K}from"@tanstack/react-query";function v(E,f,D){let U=D?.queryKey??["gql","single",f.select,f.where,f.orderBy,f.offset];return K({queryKey:U,queryFn:async()=>{return await E.querySingle(f)},enabled:D?.enabled,gcTime:D?.gcTime,staleTime:D?.staleTime,refetchOnWindowFocus:D?.refetchOnWindowFocus})}export{B as useGraphQLClient,j as useEntityUpdate,v as useEntityQuery,_ as useEntityList,$ as useEntityInsert,Y as useEntityInfiniteQuery,I as useEntityDelete,W as useEntity,S as GraphQLProvider};

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@graphql-suite/query",
-  "version": "0.8.3",
+  "version": "0.9.1",
   "description": "React Query hooks for the Drizzle GraphQL client with caching and automatic invalidation",
   "license": "MIT",
   "author": "https://github.com/dmythro",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/annexare/drizzle-graphql-suite.git",
+    "url": "git+https://github.com/annexare/graphql-suite.git",
     "directory": "packages/query"
   },
+  "homepage": "https://graphql-suite.annexare.com/query/overview/",
+  "keywords": [
+    "drizzle",
+    "graphql",
+    "react",
+    "react-query",
+    "tanstack",
+    "hooks",
+    "typescript"
+  ],
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -21,11 +31,8 @@
       "import": "./index.js"
     }
   },
-  "dependencies": {
-    "@drizzle-graphql-suite/query": "0.8.3"
-  },
   "peerDependencies": {
-    "@drizzle-graphql-suite/client": ">=0.7.0",
+    "@graphql-suite/client": ">=0.9.0",
     "@tanstack/react-query": ">=5.0.0",
     "react": ">=18.0.0"
   }

package/provider.d.ts

@@ -0,0 +1,7 @@
+import type { AnyEntityDefs, GraphQLClient, SchemaDescriptor } from '@graphql-suite/client';
+import { type ReactNode } from 'react';
+export declare function GraphQLProvider<TSchema extends SchemaDescriptor, TDefs extends AnyEntityDefs>({ client, children, }: {
+    client: GraphQLClient<TSchema, TDefs>;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useGraphQLClient<TSchema extends SchemaDescriptor = SchemaDescriptor, TDefs extends AnyEntityDefs = AnyEntityDefs>(): GraphQLClient<TSchema, TDefs>;

package/test-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/test-utils.d.ts

@@ -0,0 +1,40 @@
+import './test-setup';
+import { QueryClient } from '@tanstack/react-query';
+import { type ReactNode } from 'react';
+type RenderHookOptions = {
+    wrapper?: (props: {
+        children: ReactNode;
+    }) => ReactNode;
+};
+type RenderHookResult<T> = {
+    result: {
+        current: T;
+    };
+    rerender: () => void;
+    unmount: () => void;
+};
+export declare function renderHook<T>(callback: () => T, options?: RenderHookOptions): RenderHookResult<T>;
+export declare function renderHookAsync<T>(callback: () => T, options?: RenderHookOptions): Promise<RenderHookResult<T>>;
+type MockParams = any;
+export declare function createMockEntityClient(): {
+    query: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown>[]>>;
+    querySingle: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown> | null>>;
+    count: import("bun:test").Mock<(p: MockParams) => Promise<number>>;
+    insert: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown>[]>>;
+    insertSingle: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown> | null>>;
+    update: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown>[]>>;
+    delete: import("bun:test").Mock<(p: MockParams) => Promise<Record<string, unknown>[]>>;
+};
+export declare function createMockGraphQLClient(entityClient?: any): {
+    entity: import("bun:test").Mock<(name: string) => any>;
+    url: string;
+    schema: {};
+    execute: import("bun:test").Mock<() => Promise<{
+        data: {};
+    }>>;
+};
+export declare function createTestQueryClient(): QueryClient;
+export declare function createWrapper(mockClient: any, queryClient?: QueryClient): ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/types.d.ts

@@ -0,0 +1,4 @@
+import type { AnyEntityDefs, GraphQLClient, SchemaDescriptor } from '@graphql-suite/client';
+export type GraphQLClientContext<TSchema extends SchemaDescriptor = SchemaDescriptor, TDefs extends AnyEntityDefs = AnyEntityDefs> = {
+    client: GraphQLClient<TSchema, TDefs>;
+};

package/useEntity.d.ts

@@ -0,0 +1,2 @@
+import type { AnyEntityDefs, EntityClient, EntityDefsRef, SchemaDescriptor } from '@graphql-suite/client';
+export declare function useEntity<TSchema extends SchemaDescriptor, TDefs extends AnyEntityDefs, TEntityName extends string & keyof TSchema & keyof TDefs>(entityName: TEntityName): EntityClient<EntityDefsRef<TDefs>, TEntityName>;

package/useEntityInfiniteQuery.d.ts

@@ -0,0 +1,26 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, EntityDefsRef, InferResult } from '@graphql-suite/client';
+import { type UseInfiniteQueryResult } from '@tanstack/react-query';
+type EntityInfiniteParams<TEntity extends EntityDef, TSelect extends Record<string, unknown>> = {
+    select: TSelect;
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+    pageSize: number;
+    orderBy?: TEntity extends {
+        orderBy: infer O;
+    } ? O : never;
+};
+type EntityInfiniteOptions = {
+    enabled?: boolean;
+    gcTime?: number;
+    staleTime?: number;
+    queryKey?: unknown[];
+};
+type PageData<T> = {
+    items: T[];
+    count: number;
+};
+export declare function useEntityInfiniteQuery<TDefs extends AnyEntityDefs, TEntityName extends string, TSelect extends Record<string, unknown>>(entity: EntityClient<EntityDefsRef<TDefs>, TEntityName>, params: EntityInfiniteParams<TDefs[TEntityName] & EntityDef, TSelect>, options?: EntityInfiniteOptions): UseInfiniteQueryResult<{
+    pages: PageData<InferResult<TDefs, TDefs[TEntityName] & EntityDef, TSelect>>[];
+}>;
+export {};

package/useEntityList.d.ts

@@ -0,0 +1,22 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, EntityDefsRef, InferResult } from '@graphql-suite/client';
+import { type UseQueryResult } from '@tanstack/react-query';
+type EntityListParams<TEntity extends EntityDef, TSelect extends Record<string, unknown>> = {
+    select: TSelect;
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+    limit?: number;
+    offset?: number;
+    orderBy?: TEntity extends {
+        orderBy: infer O;
+    } ? O : never;
+};
+type EntityListOptions = {
+    enabled?: boolean;
+    gcTime?: number;
+    staleTime?: number;
+    refetchOnWindowFocus?: boolean;
+    queryKey?: unknown[];
+};
+export declare function useEntityList<TDefs extends AnyEntityDefs, TEntityName extends string, TSelect extends Record<string, unknown>>(entity: EntityClient<EntityDefsRef<TDefs>, TEntityName>, params: EntityListParams<TDefs[TEntityName] & EntityDef, TSelect>, options?: EntityListOptions): UseQueryResult<InferResult<TDefs, TDefs[TEntityName] & EntityDef, TSelect>[]>;
+export {};

package/useEntityMutation.d.ts

@@ -0,0 +1,41 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, EntityDefsRef, InferResult } from '@graphql-suite/client';
+import { type UseMutationResult } from '@tanstack/react-query';
+type InsertOptions<TResult> = {
+    invalidate?: boolean;
+    invalidateKey?: unknown[];
+    onSuccess?: (data: TResult) => void;
+    onError?: (error: Error) => void;
+};
+export declare function useEntityInsert<TDefs extends AnyEntityDefs, TEntityName extends string, TSelect extends Record<string, unknown>>(entity: EntityClient<EntityDefsRef<TDefs>, TEntityName>, returning?: TSelect, options?: InsertOptions<InferResult<TDefs, TDefs[TEntityName] & EntityDef, TSelect>[]>): UseMutationResult<InferResult<TDefs, TDefs[TEntityName] & EntityDef, TSelect>[], Error, {
+    values: TDefs[TEntityName] & EntityDef extends {
+        insertInput: infer I;
+    } ? I[] : never;
+}>;
+type UpdateParams<TEntity extends EntityDef> = {
+    set: TEntity extends {
+        updateInput: infer U;
+    } ? U : never;
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+};
+type UpdateOptions<TResult> = {
+    invalidate?: boolean;
+    invalidateKey?: unknown[];
+    onSuccess?: (data: TResult) => void;
+    onError?: (error: Error) => void;
+};
+export declare function useEntityUpdate<TDefs extends AnyEntityDefs, TEntityName extends string, TSelect extends Record<string, unknown>>(entity: EntityClient<EntityDefsRef<TDefs>, TEntityName>, returning?: TSelect, options?: UpdateOptions<InferResult<TDefs, TDefs[TEntityName] & EntityDef, TSelect>[]>): UseMutationResult<InferResult<TDefs, TDefs[TEntityName] & EntityDef, TSelect>[], Error, UpdateParams<TDefs[TEntityName] & EntityDef>>;
+type DeleteParams<TEntity extends EntityDef> = {
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+};
+type DeleteOptions<TResult> = {
+    invalidate?: boolean;
+    invalidateKey?: unknown[];
+    onSuccess?: (data: TResult) => void;
+    onError?: (error: Error) => void;
+};
+export declare function useEntityDelete<TDefs extends AnyEntityDefs, TEntityName extends string, TSelect extends Record<string, unknown>>(entity: EntityClient<EntityDefsRef<TDefs>, TEntityName>, returning?: TSelect, options?: DeleteOptions<InferResult<TDefs, TDefs[TEntityName] & EntityDef, TSelect>[]>): UseMutationResult<InferResult<TDefs, TDefs[TEntityName] & EntityDef, TSelect>[], Error, DeleteParams<TDefs[TEntityName] & EntityDef>>;
+export {};

package/useEntityQuery.d.ts

@@ -0,0 +1,21 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, EntityDefsRef, InferResult } from '@graphql-suite/client';
+import { type UseQueryResult } from '@tanstack/react-query';
+type EntityQueryParams<TEntity extends EntityDef, TSelect extends Record<string, unknown>> = {
+    select: TSelect;
+    where?: TEntity extends {
+        filters: infer F;
+    } ? F : never;
+    offset?: number;
+    orderBy?: TEntity extends {
+        orderBy: infer O;
+    } ? O : never;
+};
+type EntityQueryOptions = {
+    enabled?: boolean;
+    gcTime?: number;
+    staleTime?: number;
+    refetchOnWindowFocus?: boolean;
+    queryKey?: unknown[];
+};
+export declare function useEntityQuery<TDefs extends AnyEntityDefs, TEntityName extends string, TSelect extends Record<string, unknown>>(entity: EntityClient<EntityDefsRef<TDefs>, TEntityName>, params: EntityQueryParams<TDefs[TEntityName] & EntityDef, TSelect>, options?: EntityQueryOptions): UseQueryResult<InferResult<TDefs, TDefs[TEntityName] & EntityDef, TSelect> | null>;
+export {};