@drizzle-graphql-suite/query 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Annexare Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,276 @@
+# @drizzle-graphql-suite/query
+
+TanStack React Query hooks for `drizzle-graphql-suite/client` — type-safe data fetching with caching, pagination, and mutations.
+
+## Setup
+
+### Provider
+
+Wrap your app with `<GraphQLProvider>` inside a `<QueryClientProvider>`:
+
+```tsx
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { GraphQLProvider } from 'drizzle-graphql-suite/query'
+import { client } from './graphql-client'
+
+const queryClient = new QueryClient()
+
+function App() {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <GraphQLProvider client={client}>
+        {/* your app */}
+      </GraphQLProvider>
+    </QueryClientProvider>
+  )
+}
+```
+
+### `useGraphQLClient()`
+
+Access the raw `GraphQLClient` instance from context:
+
+```ts
+import { useGraphQLClient } from 'drizzle-graphql-suite/query'
+
+function MyComponent() {
+  const client = useGraphQLClient()
+  // client.entity('user'), client.execute(query, variables), etc.
+}
+```
+
+### `useEntity(entityName)`
+
+Get a typed `EntityClient` for use with query and mutation hooks:
+
+```ts
+import { useEntity } from 'drizzle-graphql-suite/query'
+
+function UserList() {
+  const user = useEntity('user')
+  // Pass `user` to useEntityList, useEntityQuery, etc.
+}
+```
+
+## Query Hooks
+
+### `useEntityList(entity, params, options?)`
+
+Fetch a list of records. Returns `UseQueryResult<T[]>`.
+
+**Params**: `select`, `where`, `limit`, `offset`, `orderBy`
+
+```tsx
+import { useEntity, useEntityList } from 'drizzle-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>
+  )
+}
+```
+
+### `useEntityQuery(entity, params, options?)`
+
+Fetch a single record. Returns `UseQueryResult<T | null>`.
+
+**Params**: `select`, `where`, `offset`, `orderBy`
+
+```tsx
+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 } },
+  })
+
+  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) ?? []
+
+  return (
+    <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>
+  )
+}
+```
+
+### 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 { mutate, isPending } = useEntityInsert(
+    user,
+    { id: true, name: true },
+    { onSuccess: (data) => console.log('Created:', data) },
+  )
+
+  return (
+    <button
+      disabled={isPending}
+      onClick={() => mutate({
+        values: [{ name: 'Alice', email: 'alice@example.com' }],
+      })}
+    >
+      Create User
+    </button>
+  )
+}
+```
+
+### `useEntityUpdate(entity, returning?, options?)`
+
+Update records. Call `.mutate({ set, where })` to execute.
+
+```tsx
+function UpdateRole({ userId }: { userId: string }) {
+  const user = useEntity('user')
+  const { mutate } = useEntityUpdate(user, { id: true, role: true })
+
+  return (
+    <button onClick={() => mutate({
+      set: { role: 'admin' },
+      where: { id: { eq: userId } },
+    })}>
+      Make Admin
+    </button>
+  )
+}
+```
+
+### `useEntityDelete(entity, returning?, options?)`
+
+Delete records. Call `.mutate({ where })` to execute.
+
+```tsx
+function DeleteUser({ userId }: { userId: string }) {
+  const user = useEntity('user')
+  const { mutate } = useEntityDelete(user, { id: true })
+
+  return (
+    <button onClick={() => mutate({
+      where: { id: { eq: userId } },
+    })}>
+      Delete
+    </button>
+  )
+}
+```
+
+### 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
+const { mutate } = useEntityUpdate(user, { id: true }, {
+  invalidateKey: ['gql', 'list'], // only invalidate list queries
+})
+```
+
+### Disable Invalidation
+
+```ts
+const { mutate } = useEntityInsert(user, undefined, {
+  invalidate: false,
+})
+```
+
+### Query Key Override
+
+Override the auto-generated key on query hooks for fine-grained cache control:
+
+```ts
+const { data } = useEntityList(user, params, {
+  queryKey: ['users', 'admin-list'],
+})
+```
+
+## Type Inference Flow
+
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,172 @@
+// src/provider.tsx
+import { createContext, useContext } from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+"use client";
+var GraphQLClientContext = createContext(null);
+function GraphQLProvider({
+  client,
+  children
+}) {
+  return /* @__PURE__ */ jsxDEV(GraphQLClientContext.Provider, {
+    value: client,
+    children
+  }, undefined, false, undefined, this);
+}
+function useGraphQLClient() {
+  const client = useContext(GraphQLClientContext);
+  if (!client) {
+    throw new Error("useGraphQLClient must be used within a <GraphQLProvider>");
+  }
+  return client;
+}
+// src/useEntity.ts
+import { useMemo } from "react";
+function useEntity(entityName) {
+  const client = useGraphQLClient();
+  return useMemo(() => client.entity(entityName), [client, entityName]);
+}
+// src/useEntityInfiniteQuery.ts
+import { useInfiniteQuery } from "@tanstack/react-query";
+function useEntityInfiniteQuery(entity, params, options) {
+  const queryKey = options?.queryKey ?? [
+    "gql",
+    "infinite",
+    params.select,
+    params.where,
+    params.orderBy,
+    params.pageSize
+  ];
+  return useInfiniteQuery({
+    queryKey,
+    initialPageParam: 0,
+    queryFn: async ({ pageParam = 0 }) => {
+      const queryParams = {
+        ...params,
+        limit: params.pageSize,
+        offset: pageParam * params.pageSize
+      };
+      const items = await entity.query(queryParams);
+      const count = await entity.count({ where: params.where });
+      return {
+        items,
+        count
+      };
+    },
+    getNextPageParam: (lastPage, allPages) => {
+      const totalFetched = allPages.length * params.pageSize;
+      return totalFetched < lastPage.count ? allPages.length : undefined;
+    },
+    enabled: options?.enabled,
+    gcTime: options?.gcTime,
+    staleTime: options?.staleTime
+  });
+}
+// src/useEntityList.ts
+import { useQuery } from "@tanstack/react-query";
+function useEntityList(entity, params, options) {
+  const queryKey = options?.queryKey ?? [
+    "gql",
+    "list",
+    params.select,
+    params.where,
+    params.orderBy,
+    params.limit,
+    params.offset
+  ];
+  return useQuery({
+    queryKey,
+    queryFn: async () => {
+      return await entity.query(params);
+    },
+    enabled: options?.enabled,
+    gcTime: options?.gcTime,
+    staleTime: options?.staleTime,
+    refetchOnWindowFocus: options?.refetchOnWindowFocus
+  });
+}
+// src/useEntityMutation.ts
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+function useEntityInsert(entity, returning, options) {
+  const queryClient = useQueryClient();
+  const shouldInvalidate = options?.invalidate !== false;
+  return useMutation({
+    mutationFn: async (params) => {
+      return await entity.insert({ ...params, returning });
+    },
+    onSuccess: (data) => {
+      if (shouldInvalidate) {
+        const key = options?.invalidateKey ?? ["gql"];
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+      options?.onSuccess?.(data);
+    },
+    onError: options?.onError
+  });
+}
+function useEntityUpdate(entity, returning, options) {
+  const queryClient = useQueryClient();
+  const shouldInvalidate = options?.invalidate !== false;
+  return useMutation({
+    mutationFn: async (params) => {
+      return await entity.update({ ...params, returning });
+    },
+    onSuccess: (data) => {
+      if (shouldInvalidate) {
+        const key = options?.invalidateKey ?? ["gql"];
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+      options?.onSuccess?.(data);
+    },
+    onError: options?.onError
+  });
+}
+function useEntityDelete(entity, returning, options) {
+  const queryClient = useQueryClient();
+  const shouldInvalidate = options?.invalidate !== false;
+  return useMutation({
+    mutationFn: async (params) => {
+      return await entity.delete({ ...params, returning });
+    },
+    onSuccess: (data) => {
+      if (shouldInvalidate) {
+        const key = options?.invalidateKey ?? ["gql"];
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+      options?.onSuccess?.(data);
+    },
+    onError: options?.onError
+  });
+}
+// src/useEntityQuery.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useEntityQuery(entity, params, options) {
+  const queryKey = options?.queryKey ?? [
+    "gql",
+    "single",
+    params.select,
+    params.where,
+    params.orderBy,
+    params.offset
+  ];
+  return useQuery2({
+    queryKey,
+    queryFn: async () => {
+      return await entity.querySingle(params);
+    },
+    enabled: options?.enabled,
+    gcTime: options?.gcTime,
+    staleTime: options?.staleTime,
+    refetchOnWindowFocus: options?.refetchOnWindowFocus
+  });
+}
+export {
+  useGraphQLClient,
+  useEntityUpdate,
+  useEntityQuery,
+  useEntityList,
+  useEntityInsert,
+  useEntityInfiniteQuery,
+  useEntityDelete,
+  useEntity,
+  GraphQLProvider
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@drizzle-graphql-suite/query",
+  "version": "0.5.0",
+  "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",
+    "directory": "packages/query"
+  },
+  "homepage": "https://github.com/annexare/drizzle-graphql-suite/tree/main/packages/query#readme",
+  "keywords": [
+    "drizzle",
+    "graphql",
+    "react",
+    "react-query",
+    "tanstack",
+    "hooks",
+    "typescript"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "peerDependencies": {
+    "@drizzle-graphql-suite/client": ">=0.5.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 '@drizzle-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 '@drizzle-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, EntityDef, SchemaDescriptor } from '@drizzle-graphql-suite/client';
+export declare function useEntity<TSchema extends SchemaDescriptor, TDefs extends AnyEntityDefs, TEntityName extends string & keyof TSchema>(entityName: TEntityName): TEntityName extends keyof TDefs ? EntityClient<TDefs, TDefs[TEntityName] & EntityDef> : EntityClient<TDefs, EntityDef>;

package/useEntityInfiniteQuery.d.ts

@@ -0,0 +1,26 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, InferResult } from '@drizzle-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, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, params: EntityInfiniteParams<TEntity, TSelect>, options?: EntityInfiniteOptions): UseInfiniteQueryResult<{
+    pages: PageData<InferResult<TDefs, TEntity, TSelect>>[];
+}>;
+export {};

package/useEntityList.d.ts

@@ -0,0 +1,22 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, InferResult } from '@drizzle-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, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, params: EntityListParams<TEntity, TSelect>, options?: EntityListOptions): UseQueryResult<InferResult<TDefs, TEntity, TSelect>[]>;
+export {};

package/useEntityMutation.d.ts

@@ -0,0 +1,41 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, InferResult } from '@drizzle-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, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, returning?: TSelect, options?: InsertOptions<InferResult<TDefs, TEntity, TSelect>[]>): UseMutationResult<InferResult<TDefs, TEntity, TSelect>[], Error, {
+    values: TEntity 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, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, returning?: TSelect, options?: UpdateOptions<InferResult<TDefs, TEntity, TSelect>[]>): UseMutationResult<InferResult<TDefs, TEntity, TSelect>[], Error, UpdateParams<TEntity>>;
+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, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, returning?: TSelect, options?: DeleteOptions<InferResult<TDefs, TEntity, TSelect>[]>): UseMutationResult<InferResult<TDefs, TEntity, TSelect>[], Error, DeleteParams<TEntity>>;
+export {};

package/useEntityQuery.d.ts

@@ -0,0 +1,21 @@
+import type { AnyEntityDefs, EntityClient, EntityDef, InferResult } from '@drizzle-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, TEntity extends EntityDef, TSelect extends Record<string, unknown>>(entity: EntityClient<TDefs, TEntity>, params: EntityQueryParams<TEntity, TSelect>, options?: EntityQueryOptions): UseQueryResult<InferResult<TDefs, TEntity, TSelect> | null>;
+export {};