@drizzle-graphql-suite/query 0.8.3 → 0.9.1

package/README.md

@@ -1,299 +1,11 @@
-# @drizzle-graphql-suite/query
+# Deprecated
 
-> Part of [`drizzle-graphql-suite`](https://github.com/annexare/drizzle-graphql-suite).
-> See also: [`schema`](https://github.com/annexare/drizzle-graphql-suite/tree/main/packages/schema) | [`client`](https://github.com/annexare/drizzle-graphql-suite/tree/main/packages/client)
+This package has been renamed to `@graphql-suite/query`.
 
-TanStack React Query hooks for `drizzle-graphql-suite/client` — type-safe data fetching with caching, pagination, and mutations.
-
-## Installation
-
-```bash
-bun add @drizzle-graphql-suite/query
-```
-
-```bash
-npm install @drizzle-graphql-suite/query
-```
-
-Or install the full suite:
-
-```bash
-bun add drizzle-graphql-suite
-```
+Please update your dependencies:
 
 ```bash
-npm install drizzle-graphql-suite
-```
-
-## 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.
-}
+bun add @graphql-suite/query
 ```
 
-### `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
-```
+Documentation: https://graphql-suite.annexare.com

package/index.d.ts

@@ -1,7 +1 @@
-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';
+export * from '@graphql-suite/query'

package/index.js

@@ -1 +1 @@
-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};
+export * from '@graphql-suite/query'

package/package.json

@@ -1,24 +1,14 @@
 {
   "name": "@drizzle-graphql-suite/query",
-  "version": "0.8.3",
-  "description": "React Query hooks for the Drizzle GraphQL client with caching and automatic invalidation",
+  "version": "0.9.1",
+  "description": "[DEPRECATED] Use @graphql-suite/query instead. 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"
+    "url": "https://github.com/annexare/graphql-suite.git"
   },
-  "homepage": "https://github.com/annexare/drizzle-graphql-suite/tree/main/packages/query#readme",
-  "keywords": [
-    "drizzle",
-    "graphql",
-    "react",
-    "react-query",
-    "tanstack",
-    "hooks",
-    "typescript"
-  ],
+  "homepage": "https://graphql-suite.annexare.com",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -31,9 +21,7 @@
       "import": "./index.js"
     }
   },
-  "peerDependencies": {
-    "@drizzle-graphql-suite/client": ">=0.7.0",
-    "@tanstack/react-query": ">=5.0.0",
-    "react": ">=18.0.0"
+  "dependencies": {
+    "@graphql-suite/query": "0.9.1"
   }
 }

package/provider.d.ts

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

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

package/test-utils.d.ts

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

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

@@ -1,2 +0,0 @@
-import type { AnyEntityDefs, EntityClient, EntityDefsRef, SchemaDescriptor } from '@drizzle-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

@@ -1,26 +0,0 @@
-import type { AnyEntityDefs, EntityClient, EntityDef, EntityDefsRef, 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, 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

@@ -1,22 +0,0 @@
-import type { AnyEntityDefs, EntityClient, EntityDef, EntityDefsRef, 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, 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

@@ -1,41 +0,0 @@
-import type { AnyEntityDefs, EntityClient, EntityDef, EntityDefsRef, 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, 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

@@ -1,21 +0,0 @@
-import type { AnyEntityDefs, EntityClient, EntityDef, EntityDefsRef, 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, 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 {};