@graphql-suite/client 0.8.3 → 0.9.1

package/README.md

@@ -1,191 +1,259 @@
-[![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/client
 
-# 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) | [`query`](https://github.com/annexare/graphql-suite/tree/main/packages/query)
 
-Auto-generated GraphQL CRUD, type-safe clients, and React Query hooks from Drizzle PostgreSQL schemas.
-
-## 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.
-
-## Packages
-
-| 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 |
+Type-safe GraphQL client auto-generated from Drizzle schemas, with full TypeScript inference for queries, mutations, filters, and relations.
 
 ## Installation
 
 ```bash
-bun add drizzle-graphql-suite
+bun add @graphql-suite/client
 ```
 
 ```bash
-npm install drizzle-graphql-suite
+npm install @graphql-suite/client
 ```
 
-## Peer Dependencies
+Or install the full suite:
 
-Each subpath import has its own peer dependency requirements:
+```bash
+bun add graphql-suite
+```
 
-| 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 |
+```bash
+npm install graphql-suite
+```
 
 ## Quick Start
 
-### 1. Server — Build GraphQL Schema
+### From Drizzle Schema (recommended)
+
+Use `createDrizzleClient` to create a client that infers all types directly from your Drizzle schema module — no code generation needed.
 
 ```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 { createDrizzleClient } from '@graphql-suite/client'
+import * as schema from './db/schema'
+
+const client = createDrizzleClient({
+  schema,
+  config: {
+    suffixes: { list: 's' },
+    tables: { exclude: ['session', 'verification'] },
   },
+  url: '/api/graphql',
+  headers: { Authorization: 'Bearer ...' },
 })
-
-const yoga = createYoga({ schema })
-const server = createServer(yoga)
-server.listen(4000)
 ```
 
-#### Per-Role Schemas (Optional)
+### From Schema Descriptor (separate-repo setups)
+
+Use `createClient` with a codegen-generated schema descriptor when the client is in a separate repository that can't import the Drizzle schema directly.
 
 ```ts
-import { permissive, restricted, readOnly } from 'drizzle-graphql-suite/schema'
+import { createClient } from '@graphql-suite/client'
+import { schema, type EntityDefs } from './generated/entity-defs'
 
-// 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 } })),
-}
+const client = createClient<typeof schema, EntityDefs>({
+  schema,
+  url: '/api/graphql',
+})
 ```
 
-### 2. Client — Type-Safe Queries
+## EntityClient API
+
+Access a typed entity client via `client.entity('name')`:
 
 ```ts
-import { createDrizzleClient } from 'drizzle-graphql-suite/client'
-import * as schema from './db/schema'
+const user = client.entity('user')
+```
 
-const client = createDrizzleClient({
-  schema,
-  config: { suffixes: { list: 's' } },
-  url: '/api/graphql',
-})
+Each entity client provides the following methods:
+
+### `query(params)`
+
+Fetch a list of records with optional filtering, pagination, and ordering. Returns `T[]`.
 
-const users = await client.entity('user').query({
+```ts
+const users = await user.query({
   select: {
     id: true,
     name: true,
-    posts: { id: true, title: true },
+    email: true,
+    posts: {
+      id: true,
+      title: true,
+      comments: { id: true, body: true },
+    },
   },
-  where: { name: { ilike: '%john%' } },
-  limit: 10,
+  where: { email: { ilike: '%@example.com' } },
+  orderBy: { name: { direction: 'asc', priority: 1 } },
+  limit: 20,
+  offset: 0,
 })
 ```
 
-### 3. React — Query Hooks
+### `querySingle(params)`
 
-```tsx
-import { GraphQLProvider, useEntity, useEntityList } from 'drizzle-graphql-suite/query'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+Fetch a single record. Returns `T | null`.
 
-const queryClient = new QueryClient()
+```ts
+const found = await user.querySingle({
+  select: { id: true, name: true, email: true },
+  where: { id: { eq: 'some-uuid' } },
+})
+```
 
-function App() {
-  return (
-    <QueryClientProvider client={queryClient}>
-      <GraphQLProvider client={graphqlClient}>
-        <UserList />
-      </GraphQLProvider>
-    </QueryClientProvider>
-  )
-}
+### `count(params?)`
 
-function UserList() {
-  const user = useEntity('user')
-  const { data, isLoading } = useEntityList(user, {
-    select: { id: true, name: true, email: true },
-    limit: 20,
-  })
+Count matching records. Returns `number`.
 
-  if (isLoading) return <div>Loading...</div>
-  return <ul>{data?.map((u) => <li key={u.id}>{u.name}</li>)}</ul>
-}
+```ts
+const total = await user.count({
+  where: { role: { eq: 'admin' } },
+})
 ```
 
-## Framework Integration Examples
+### `insert(params)`
+
+Insert multiple records. Returns `T[]` of inserted rows.
 
-`buildSchema()` returns a standard `GraphQLSchema` — here's how to serve it from popular frameworks.
+```ts
+const created = await user.insert({
+  values: [
+    { name: 'Alice', email: 'alice@example.com' },
+    { name: 'Bob', email: 'bob@example.com' },
+  ],
+  returning: { id: true, name: true },
+})
+```
 
-### Next.js App Router
+### `insertSingle(params)`
+
+Insert a single record. Returns `T | null`.
 
 ```ts
-// app/api/graphql/route.ts
-import { createYoga } from 'graphql-yoga'
-import { buildSchema } from 'drizzle-graphql-suite/schema'
-import { db } from '@/db'
+const created = await user.insertSingle({
+  values: { name: 'Alice', email: 'alice@example.com' },
+  returning: { id: true, name: true },
+})
+```
 
-const { schema } = buildSchema(db)
+### `update(params)`
 
-const { handleRequest } = createYoga({
-  schema,
-  graphqlEndpoint: '/api/graphql',
-  fetchAPI: { Response },
+Update records matching a filter. Returns `T[]` of updated rows.
+
+```ts
+const updated = await user.update({
+  set: { role: 'admin' },
+  where: { id: { eq: 'some-uuid' } },
+  returning: { id: true, role: true },
 })
+```
+
+### `delete(params)`
+
+Delete records matching a filter. Returns `T[]` of deleted rows.
 
-export { handleRequest as GET, handleRequest as POST }
+```ts
+const deleted = await user.delete({
+  where: { deletedAt: { isNotNull: true } },
+  returning: { id: true },
+})
 ```
 
-### ElysiaJS
+## Schema Descriptor
+
+A `SchemaDescriptor` is a runtime object mapping entity names to their operation names, fields, and relations. It tells the client how to build GraphQL queries.
+
+### `buildSchemaDescriptor(schema, config?)`
+
+Builds a `SchemaDescriptor` from a Drizzle schema module. This is called internally by `createDrizzleClient`, but can be used directly if you need the descriptor.
 
 ```ts
-// server.ts
-import { Elysia } from 'elysia'
-import { yoga } from '@elysiajs/graphql-yoga'
-import { buildSchema } from 'drizzle-graphql-suite/schema'
-import { db } from './db'
+import { buildSchemaDescriptor } from '@graphql-suite/client'
+import * as schema from './db/schema'
+
+const descriptor = buildSchemaDescriptor(schema, {
+  suffixes: { list: 's' },
+  tables: { exclude: ['session'] },
+  pruneRelations: { 'user.sessions': false },
+})
+```
 
-const { schema } = buildSchema(db)
+Config options mirror the schema package: `mutations`, `suffixes`, `tables.exclude`, and `pruneRelations`.
 
-new Elysia()
-  .use(yoga({ schema }))
-  .listen(3000)
+## Type Inference
+
+The client provides end-to-end type inference from Drizzle schema to query results:
+
+### `InferEntityDefs<TSchema, TConfig>`
+
+Infers the complete entity type definitions from a Drizzle schema module, including fields (with Date → string wire conversion), relations, filters, insert inputs, update inputs, and orderBy types.
+
+```ts
+import type { InferEntityDefs } from '@graphql-suite/client'
+import type * as schema from './db/schema'
+
+type MyEntityDefs = InferEntityDefs<typeof schema, { tables: { exclude: ['session'] } }>
 ```
 
-## AI Agent Skill
+### `InferResult<TDefs, TEntity, TSelect>`
 
-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.
+Infers the return type of a query from the `select` object. Only selected scalar fields and relations are included in the result type. Relations resolve to arrays or `T | null` based on their cardinality.
 
-```bash
-bunx skills add annexare/drizzle-graphql-suite
-# or: npx skills add annexare/drizzle-graphql-suite
+### `SelectInput<TDefs, TEntity>`
+
+Describes the valid shape of a `select` parameter — `true` for scalar fields, nested objects for relations.
+
+## Dynamic URL and Headers
+
+Both `url` and `headers` support static values or functions (sync or async) that are called per-request:
+
+```ts
+const client = createDrizzleClient({
+  schema,
+  config: {},
+  // Dynamic URL
+  url: () => `${getApiBase()}/graphql`,
+  // Async headers (e.g., refresh token)
+  headers: async () => ({
+    Authorization: `Bearer ${await getAccessToken()}`,
+  }),
+})
 ```
 
-## License
+## Error Handling
+
+The client throws two error types:
 
-MIT
+### `GraphQLClientError`
+
+Thrown when the server returns GraphQL errors in the response body.
+
+- **`errors`** — `Array<{ message, locations?, path?, extensions? }>` — individual GraphQL errors
+- **`status`** — HTTP status code (usually `200`)
+- **`message`** — concatenated error messages
+
+### `NetworkError`
+
+Thrown when the HTTP request fails (network error or non-2xx status).
+
+- **`status`** — HTTP status code (`0` for network failures)
+- **`message`** — error description
+
+```ts
+import { GraphQLClientError, NetworkError } from '@graphql-suite/client'
+
+try {
+  const users = await client.entity('user').query({
+    select: { id: true, name: true },
+  })
+} catch (e) {
+  if (e instanceof GraphQLClientError) {
+    console.error('GraphQL errors:', e.errors)
+  } else if (e instanceof NetworkError) {
+    console.error('Network error:', e.status, e.message)
+  }
+}
+```

package/client.d.ts

@@ -0,0 +1,19 @@
+import type { BuildSchemaConfig } from '@graphql-suite/schema';
+import { type EntityClient } from './entity';
+import type { InferEntityDefs } from './infer';
+import type { AnyEntityDefs, ClientConfig, EntityDefsRef, SchemaDescriptor } from './types';
+export declare class GraphQLClient<TSchema extends SchemaDescriptor, TDefs extends AnyEntityDefs = AnyEntityDefs> {
+    private url;
+    private schema;
+    private headers?;
+    constructor(config: ClientConfig<TSchema>);
+    entity<TEntityName extends string & keyof TSchema & keyof TDefs>(entityName: TEntityName): EntityClient<EntityDefsRef<TDefs>, TEntityName>;
+    execute(query: string, variables?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+export type DrizzleClientConfig<TSchema extends Record<string, unknown>, TConfig extends BuildSchemaConfig> = {
+    schema: TSchema;
+    config: TConfig;
+    url: string | (() => string);
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+};
+export declare function createDrizzleClient<TSchema extends Record<string, unknown>, const TConfig extends BuildSchemaConfig>(options: DrizzleClientConfig<TSchema, TConfig>): GraphQLClient<SchemaDescriptor, InferEntityDefs<TSchema, TConfig>>;

package/entity.d.ts

@@ -0,0 +1,59 @@
+import type { AnyEntityDefs, EntityDef, EntityDefsRef, EntityDescriptor, InferResult, SchemaDescriptor } from './types';
+type ResolveEntity<TRef extends EntityDefsRef<AnyEntityDefs>, TEntityName extends string> = TRef['__defs'][TEntityName] & EntityDef;
+export interface EntityClient<TRef extends EntityDefsRef<AnyEntityDefs>, TEntityName extends string> {
+    query<S extends Record<string, unknown>>(params: {
+        select: S;
+        where?: ResolveEntity<TRef, TEntityName> extends {
+            filters: infer F;
+        } ? F : never;
+        limit?: number;
+        offset?: number;
+        orderBy?: ResolveEntity<TRef, TEntityName> extends {
+            orderBy: infer O;
+        } ? O : never;
+    }): Promise<InferResult<TRef['__defs'], ResolveEntity<TRef, TEntityName>, S>[]>;
+    querySingle<S extends Record<string, unknown>>(params: {
+        select: S;
+        where?: ResolveEntity<TRef, TEntityName> extends {
+            filters: infer F;
+        } ? F : never;
+        offset?: number;
+        orderBy?: ResolveEntity<TRef, TEntityName> extends {
+            orderBy: infer O;
+        } ? O : never;
+    }): Promise<InferResult<TRef['__defs'], ResolveEntity<TRef, TEntityName>, S> | null>;
+    count(params?: {
+        where?: ResolveEntity<TRef, TEntityName> extends {
+            filters: infer F;
+        } ? F : never;
+    }): Promise<number>;
+    insert<S extends Record<string, unknown>>(params: {
+        values: ResolveEntity<TRef, TEntityName> extends {
+            insertInput: infer I;
+        } ? I[] : never;
+        returning?: S;
+    }): Promise<InferResult<TRef['__defs'], ResolveEntity<TRef, TEntityName>, S>[]>;
+    insertSingle<S extends Record<string, unknown>>(params: {
+        values: ResolveEntity<TRef, TEntityName> extends {
+            insertInput: infer I;
+        } ? I : never;
+        returning?: S;
+    }): Promise<InferResult<TRef['__defs'], ResolveEntity<TRef, TEntityName>, S> | null>;
+    update<S extends Record<string, unknown>>(params: {
+        set: ResolveEntity<TRef, TEntityName> extends {
+            updateInput: infer U;
+        } ? U : never;
+        where?: ResolveEntity<TRef, TEntityName> extends {
+            filters: infer F;
+        } ? F : never;
+        returning?: S;
+    }): Promise<InferResult<TRef['__defs'], ResolveEntity<TRef, TEntityName>, S>[]>;
+    delete<S extends Record<string, unknown>>(params: {
+        where?: ResolveEntity<TRef, TEntityName> extends {
+            filters: infer F;
+        } ? F : never;
+        returning?: S;
+    }): Promise<InferResult<TRef['__defs'], ResolveEntity<TRef, TEntityName>, S>[]>;
+}
+export declare function createEntityClient<TRef extends EntityDefsRef<AnyEntityDefs>, TEntityName extends string>(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, executeGraphQL: (query: string, variables: Record<string, unknown>) => Promise<Record<string, unknown>>): EntityClient<TRef, TEntityName>;
+export {};

package/errors.d.ts

@@ -0,0 +1,19 @@
+export type GraphQLErrorLocation = {
+    line: number;
+    column: number;
+};
+export type GraphQLErrorEntry = {
+    message: string;
+    locations?: GraphQLErrorLocation[];
+    path?: (string | number)[];
+    extensions?: Record<string, unknown>;
+};
+export declare class GraphQLClientError extends Error {
+    readonly errors: GraphQLErrorEntry[];
+    readonly status: number;
+    constructor(errors: GraphQLErrorEntry[], status?: number);
+}
+export declare class NetworkError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}

package/index.d.ts

@@ -1 +1,11 @@
-export * from '@drizzle-graphql-suite/client'
+import { GraphQLClient } from './client';
+import type { AnyEntityDefs, ClientConfig, SchemaDescriptor } from './types';
+export declare function createClient<TSchema extends SchemaDescriptor, TDefs extends AnyEntityDefs = AnyEntityDefs>(config: ClientConfig<TSchema>): GraphQLClient<TSchema, TDefs>;
+export type { BuildSchemaConfig } from '@graphql-suite/schema';
+export type { DrizzleClientConfig } from './client';
+export { createDrizzleClient, GraphQLClient } from './client';
+export type { EntityClient } from './entity';
+export { GraphQLClientError, NetworkError } from './errors';
+export type { InferEntityDefs } from './infer';
+export { buildSchemaDescriptor } from './schema-builder';
+export type { AnyEntityDefs, ClientConfig, EntityDef, EntityDefsRef, EntityDescriptor, InferResult, SchemaDescriptor, SelectInput, } from './types';

package/index.js

@@ -1 +1,25 @@
-export * from '@drizzle-graphql-suite/client'
+/** @graphql-suite/client v0.9.1 | MIT */
+var j=(E)=>E.charAt(0).toUpperCase()+E.slice(1);function G(E,x,$,Y=4){let H=" ".repeat(Y),C=[];for(let[R,J]of Object.entries(E)){if(J===!0){C.push(`${H}${R}`);continue}if(typeof J==="object"&&J!==null){let X=$.relations[R];if(!X)continue;let A=x[X.entity];if(!A)continue;let Z=G(J,x,A,Y+2);C.push(`${H}${R} {`),C.push(Z),C.push(`${H}}`)}}return C.join(`
+`)}function L(E){return`${j(E)}Filters`}function S(E){return`${j(E)}OrderBy`}function p(E){return`${j(E)}InsertInput`}function c(E){return`${j(E)}UpdateInput`}function T(E,x,$,Y,H,C,R,J){let X=x.queryListName;if(!X)throw Error(`Entity '${E}' has no list query`);let A=L(E),Z=S(E),_=`${j(X)}Query`,V=[],I=[];if(H)V.push(`$where: ${A}`),I.push("where: $where");if(C)V.push(`$orderBy: ${Z}`),I.push("orderBy: $orderBy");if(R)V.push("$limit: Int"),I.push("limit: $limit");if(J)V.push("$offset: Int"),I.push("offset: $offset");let q=V.length?`(${V.join(", ")})`:"",U=I.length?`(${I.join(", ")})`:"",F=G(Y,$,x);return{query:`query ${_}${q} {
+  ${X}${U} {
+${F}
+  }
+}`,variables:{},operationName:_}}function d(E,x,$,Y,H,C,R){let J=x.queryName;if(!J)throw Error(`Entity '${E}' has no single query`);let X=L(E),A=S(E),Z=`${j(J)}SingleQuery`,_=[],V=[];if(H)_.push(`$where: ${X}`),V.push("where: $where");if(C)_.push(`$orderBy: ${A}`),V.push("orderBy: $orderBy");if(R)_.push("$offset: Int"),V.push("offset: $offset");let I=_.length?`(${_.join(", ")})`:"",q=V.length?`(${V.join(", ")})`:"",U=G(Y,$,x);return{query:`query ${Z}${I} {
+  ${J}${q} {
+${U}
+  }
+}`,variables:{},operationName:Z}}function b(E,x,$){let Y=x.countName;if(!Y)throw Error(`Entity '${E}' has no count query`);let H=L(E),C=`${j(Y)}Query`,R=[],J=[];if($)R.push(`$where: ${H}`),J.push("where: $where");let X=R.length?`(${R.join(", ")})`:"",A=J.length?`(${J.join(", ")})`:"";return{query:`query ${C}${X} {
+  ${Y}${A}
+}`,variables:{},operationName:C}}function w(E,x,$,Y,H){let C=H?x.insertSingleName:x.insertName;if(!C)throw Error(`Entity '${E}' has no ${H?"insertSingle":"insert"} mutation`);let R=p(E),J=`${j(C)}Mutation`,A=`($values: ${H?`${R}!`:`[${R}!]!`})`,Z="(values: $values)",_="";if(Y)_=` {
+${G(Y,$,x)}
+  }`;return{query:`mutation ${J}${A} {
+  ${C}${Z}${_}
+}`,variables:{},operationName:J}}function v(E,x,$,Y,H){let C=x.updateName;if(!C)throw Error(`Entity '${E}' has no update mutation`);let R=c(E),J=L(E),X=`${j(C)}Mutation`,A=[`$set: ${R}!`],Z=["set: $set"];if(H)A.push(`$where: ${J}`),Z.push("where: $where");let _=`(${A.join(", ")})`,V=`(${Z.join(", ")})`,I="";if(Y)I=` {
+${G(Y,$,x)}
+  }`;return{query:`mutation ${X}${_} {
+  ${C}${V}${I}
+}`,variables:{},operationName:X}}function g(E,x,$,Y,H){let C=x.deleteName;if(!C)throw Error(`Entity '${E}' has no delete mutation`);let R=L(E),J=`${j(C)}Mutation`,X=[],A=[];if(H)X.push(`$where: ${R}`),A.push("where: $where");let Z=X.length?`(${X.join(", ")})`:"",_=A.length?`(${A.join(", ")})`:"",V="";if(Y)V=` {
+${G(Y,$,x)}
+  }`;return{query:`mutation ${J}${Z} {
+  ${C}${_}${V}
+}`,variables:{},operationName:J}}function D(E,x,$,Y){return{async query(H){let{select:C,where:R,limit:J,offset:X,orderBy:A}=H,Z=T(E,x,$,C,R!=null,A!=null,J!=null,X!=null),_={};if(R!=null)_.where=R;if(A!=null)_.orderBy=A;if(J!=null)_.limit=J;if(X!=null)_.offset=X;return(await Y(Z.query,_))[x.queryListName]},async querySingle(H){let{select:C,where:R,offset:J,orderBy:X}=H,A=d(E,x,$,C,R!=null,X!=null,J!=null),Z={};if(R!=null)Z.where=R;if(X!=null)Z.orderBy=X;if(J!=null)Z.offset=J;return(await Y(A.query,Z))[x.queryName]??null},async count(H){let C=H?.where,R=b(E,x,C!=null),J={};if(C!=null)J.where=C;return(await Y(R.query,J))[x.countName]},async insert(H){let{values:C,returning:R}=H,J=w(E,x,$,R,!1),X={values:C};return(await Y(J.query,X))[x.insertName]},async insertSingle(H){let{values:C,returning:R}=H,J=w(E,x,$,R,!0),X={values:C};return(await Y(J.query,X))[x.insertSingleName]??null},async update(H){let{set:C,where:R,returning:J}=H,X=v(E,x,$,J,R!=null),A={set:C};if(R!=null)A.where=R;return(await Y(X.query,A))[x.updateName]},async delete(H){let{where:C,returning:R}=H,J=g(E,x,$,R,C!=null),X={};if(C!=null)X.where=C;return(await Y(J.query,X))[x.deleteName]}}}class K extends Error{errors;status;constructor(E,x=200){let $=E.map((Y)=>Y.message).join("; ");super($);this.name="GraphQLClientError",this.errors=E,this.status=x}}class W extends Error{status;constructor(E,x){super(E);this.name="NetworkError",this.status=x}}import{getTableColumns as f,getTableName as h,is as z,Many as N,One as u,Relations as m,Table as l}from"drizzle-orm";var O=(E)=>E.charAt(0).toUpperCase()+E.slice(1);function k(E,x={}){let $=new Set(x.tables?.exclude??[]),Y=x.suffixes?.list??"s",H=new Map,C=new Map;for(let[A,Z]of Object.entries(E))if(z(Z,l)){if($.has(A))continue;let _=h(Z),V=Object.keys(f(Z));H.set(A,{table:Z,dbName:_,columns:V}),C.set(_,A)}let R=new Map;for(let A of Object.values(E)){if(!z(A,m))continue;let Z=h(A.table),_=C.get(Z);if(!_||!H.has(_))continue;let V={one:(U,F)=>{return new u(A.table,U,F,!1)},many:(U,F)=>{return new N(A.table,U,F)}},I=A.config(V),q={};for(let[U,F]of Object.entries(I)){let Q=F,P=Q.referencedTableName;if(!P)continue;let B=C.get(P);if(!B)continue;let o=z(Q,u)?"one":"many";q[U]={entity:B,type:o}}R.set(_,q)}let J=x.pruneRelations??{};for(let[A,Z]of R)for(let _ of Object.keys(Z)){let V=`${A}.${_}`;if(J[V]===!1)delete Z[_]}let X={};for(let[A,{columns:Z}]of H){let _=R.get(A)??{};X[A]={queryName:A,queryListName:`${A}${Y}`,countName:`${A}Count`,insertName:`insertInto${O(A)}`,insertSingleName:`insertInto${O(A)}Single`,updateName:`update${O(A)}`,deleteName:`deleteFrom${O(A)}`,fields:Z,relations:_}}return X}class M{url;schema;headers;constructor(E){this.url=E.url,this.schema=E.schema,this.headers=E.headers}entity(E){let x=this.schema[E];if(!x)throw Error(`Entity '${E}' not found in schema`);return D(E,x,this.schema,($,Y)=>this.execute($,Y))}async execute(E,x={}){let $=typeof this.url==="function"?this.url():this.url,Y={"Content-Type":"application/json",...typeof this.headers==="function"?await this.headers():this.headers??{}},H;try{H=await fetch($,{method:"POST",headers:Y,body:JSON.stringify({query:E,variables:x})})}catch(R){throw new W(R instanceof Error?R.message:"Network request failed",0)}if(!H.ok)throw new W(`HTTP ${H.status}: ${H.statusText}`,H.status);let C=await H.json();if(C.errors?.length)throw new K(C.errors,H.status);if(!C.data)throw new K([{message:"No data in response"}],H.status);return C.data}}function y(E){let x=k(E.schema,E.config);return new M({url:E.url,schema:x,headers:E.headers})}function RE(E){return new M(E)}export{y as createDrizzleClient,RE as createClient,k as buildSchemaDescriptor,W as NetworkError,K as GraphQLClientError,M as GraphQLClient};

package/infer.d.ts

@@ -0,0 +1,107 @@
+import type { Many, One, Relations, Table } from 'drizzle-orm';
+type ToWire<T> = T extends Date ? string : T;
+type WireFormat<T> = {
+    [K in keyof T]: ToWire<T[K]>;
+};
+type ExtractTables<TSchema> = {
+    [K in keyof TSchema as TSchema[K] extends Table ? K : never]: TSchema[K];
+};
+type FindRelationConfig<TSchema, TTableName extends string> = {
+    [K in keyof TSchema]: TSchema[K] extends Relations<TTableName, infer TConfig> ? TConfig : never;
+}[keyof TSchema];
+type MapRelation<T> = T extends One<infer N, infer TIsNullable> ? {
+    entity: N;
+    type: 'one';
+    required: TIsNullable;
+} : T extends Many<infer N> ? {
+    entity: N;
+    type: 'many';
+} : never;
+type InferRelationDefs<TSchema, TTableName extends string> = {
+    [K in keyof FindRelationConfig<TSchema, TTableName>]: MapRelation<FindRelationConfig<TSchema, TTableName>[K]>;
+};
+type ScalarFilterOps<T> = {
+    eq?: T | null;
+    ne?: T | null;
+    lt?: T | null;
+    lte?: T | null;
+    gt?: T | null;
+    gte?: T | null;
+    like?: string | null;
+    notLike?: string | null;
+    ilike?: string | null;
+    notIlike?: string | null;
+    inArray?: T[] | null;
+    notInArray?: T[] | null;
+    isNull?: boolean | null;
+    isNotNull?: boolean | null;
+};
+type ScalarColumnFilters<TFields> = {
+    [K in keyof TFields]?: ScalarFilterOps<NonNullable<TFields[K]>>;
+};
+type ManyRelationFilter<TFilter> = {
+    some?: TFilter;
+    every?: TFilter;
+    none?: TFilter;
+};
+type IsResolvableRelation<TSchema, TRel> = TRel extends {
+    entity: infer E;
+} ? E extends string ? KeyForDbName<TSchema, E> extends keyof ExtractTables<TSchema> ? true : false : false : false;
+type Prev<T extends unknown[]> = T extends [unknown, ...infer Rest] ? Rest : [];
+type InferRelationFilterFields<TSchema, TRels, TDepth extends unknown[]> = {
+    [K in keyof TRels as IsResolvableRelation<TSchema, TRels[K]> extends true ? K : never]?: TRels[K] extends {
+        entity: infer E;
+        type: infer TRelType;
+    } ? E extends string ? KeyForDbName<TSchema, E> extends infer RK ? RK extends keyof ExtractTables<TSchema> ? ExtractTables<TSchema>[RK] extends infer TTarget ? TTarget extends Table ? TRelType extends 'many' ? ManyRelationFilter<InferEntityFilters<TSchema, TTarget, Prev<TDepth>>> : InferEntityFilters<TSchema, TTarget, Prev<TDepth>> : never : never : never : never : never : never;
+};
+type InferEntityFilters<TSchema, T extends Table, TDepth extends unknown[] = [0]> = ScalarColumnFilters<WireFormat<T['$inferSelect']>> & (TDepth extends [] ? {} : InferRelationFilterFields<TSchema, InferRelationDefs<TSchema, TableDbName<T>>, TDepth>) & {
+    OR?: InferEntityFilters<TSchema, T, TDepth>[];
+};
+type InferInsertInput<T> = T extends Table ? WireFormat<T['$inferInsert']> : never;
+type InferUpdateInput<T> = T extends Table ? {
+    [K in keyof T['$inferInsert']]?: ToWire<T['$inferInsert'][K]> | null;
+} : never;
+type InferOrderBy<T> = T extends Table ? {
+    [K in keyof T['$inferSelect']]?: {
+        direction: 'asc' | 'desc';
+        priority: number;
+    };
+} : never;
+type ExcludedNames<TConfig> = TConfig extends {
+    tables: {
+        exclude: readonly (infer T)[];
+    };
+} ? T : never;
+type NumberToTuple<N extends number, T extends unknown[] = []> = T['length'] extends N ? T : T['length'] extends 5 ? T : NumberToTuple<N, [...T, 0]>;
+type ExtractFilterDepth<TConfig> = TConfig extends {
+    limitRelationDepth: infer D;
+} ? D extends number ? number extends D ? [0] : NumberToTuple<D> : [0] : [0];
+type TableDbName<T> = T extends Table<infer TConfig> ? TConfig['name'] extends string ? TConfig['name'] : string : string;
+type DbNameToKey<TSchema> = {
+    [K in keyof ExtractTables<TSchema>]: TableDbName<ExtractTables<TSchema>[K]>;
+};
+type KeyForDbName<TSchema, TDbName extends string> = {
+    [K in keyof DbNameToKey<TSchema>]: DbNameToKey<TSchema>[K] extends TDbName ? K : never;
+}[keyof DbNameToKey<TSchema>];
+type ResolveRelationEntity<TSchema, TDbName extends string> = KeyForDbName<TSchema, TDbName> extends infer K ? (K extends string ? K : TDbName) : TDbName;
+type ResolveRelationDefs<TSchema, TRels> = {
+    [K in keyof TRels]: TRels[K] extends {
+        entity: infer E;
+        type: infer T;
+    } ? E extends string ? Omit<TRels[K], 'entity'> & {
+        entity: ResolveRelationEntity<TSchema, E>;
+        type: T;
+    } : TRels[K] : TRels[K];
+};
+type BuildEntityDef<TSchema, T, TDepth extends unknown[]> = T extends Table ? {
+    fields: WireFormat<T['$inferSelect']>;
+    relations: ResolveRelationDefs<TSchema, InferRelationDefs<TSchema, TableDbName<T>>>;
+    filters: InferEntityFilters<TSchema, T, TDepth>;
+    insertInput: InferInsertInput<T>;
+    updateInput: InferUpdateInput<T>;
+    orderBy: InferOrderBy<T>;
+} : never;
+export type InferEntityDefs<TSchema, TConfig = Record<string, never>> = {
+    [K in keyof ExtractTables<TSchema> as K extends ExcludedNames<TConfig> ? never : K extends string ? K : never]: BuildEntityDef<TSchema, ExtractTables<TSchema>[K], ExtractFilterDepth<TConfig>>;
+};
+export {};

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@graphql-suite/client",
-  "version": "0.8.3",
+  "version": "0.9.1",
   "description": "Type-safe GraphQL client with entity-based API and full Drizzle type inference",
   "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/client"
   },
+  "homepage": "https://graphql-suite.annexare.com/client/overview/",
+  "keywords": [
+    "drizzle",
+    "graphql",
+    "client",
+    "type-safe",
+    "typescript",
+    "orm",
+    "query-builder"
+  ],
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -21,11 +31,8 @@
       "import": "./index.js"
     }
   },
-  "dependencies": {
-    "@drizzle-graphql-suite/client": "0.8.3"
-  },
   "peerDependencies": {
-    "@drizzle-graphql-suite/schema": ">=0.8.0",
+    "@graphql-suite/schema": ">=0.9.0",
     "drizzle-orm": ">=0.44.0"
   }
 }

package/query-builder.d.ts

@@ -0,0 +1,12 @@
+import type { EntityDescriptor, SchemaDescriptor } from './types';
+export type BuiltQuery = {
+    query: string;
+    variables: Record<string, unknown>;
+    operationName: string;
+};
+export declare function buildListQuery(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, select: Record<string, unknown>, hasWhere: boolean, hasOrderBy: boolean, hasLimit: boolean, hasOffset: boolean): BuiltQuery;
+export declare function buildSingleQuery(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, select: Record<string, unknown>, hasWhere: boolean, hasOrderBy: boolean, hasOffset: boolean): BuiltQuery;
+export declare function buildCountQuery(entityName: string, entityDef: EntityDescriptor, hasWhere: boolean): BuiltQuery;
+export declare function buildInsertMutation(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, returning: Record<string, unknown> | undefined, isSingle: boolean): BuiltQuery;
+export declare function buildUpdateMutation(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, returning: Record<string, unknown> | undefined, hasWhere: boolean): BuiltQuery;
+export declare function buildDeleteMutation(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, returning: Record<string, unknown> | undefined, hasWhere: boolean): BuiltQuery;

package/schema-builder.d.ts

@@ -0,0 +1,3 @@
+import type { BuildSchemaConfig } from '@graphql-suite/schema';
+import type { SchemaDescriptor } from './types';
+export declare function buildSchemaDescriptor(schema: Record<string, unknown>, config?: BuildSchemaConfig): SchemaDescriptor;

package/types.d.ts

@@ -0,0 +1,50 @@
+export type RelationDef = {
+    entity: string;
+    type: 'one' | 'many';
+    required?: boolean;
+};
+export type EntityDef = {
+    fields: Record<string, unknown>;
+    relations: Record<string, RelationDef>;
+    filters?: Record<string, unknown>;
+    insertInput?: Record<string, unknown>;
+    updateInput?: Record<string, unknown>;
+    orderBy?: Record<string, unknown>;
+};
+export type AnyEntityDefs = Record<string, EntityDef>;
+/** Opaque wrapper that prevents TS from expanding entity defs during serialization */
+export interface EntityDefsRef<TDefs extends AnyEntityDefs> {
+    readonly __defs: TDefs;
+}
+export type EntityDescriptor = {
+    queryName: string;
+    queryListName: string;
+    countName: string;
+    insertName: string;
+    insertSingleName: string;
+    updateName: string;
+    deleteName: string;
+    fields: readonly string[];
+    relations: Record<string, {
+        entity: string;
+        type: 'one' | 'many';
+    }>;
+};
+export type SchemaDescriptor = Record<string, EntityDescriptor>;
+export type SelectInput<TDefs extends AnyEntityDefs, TEntity extends EntityDef> = {
+    [K in keyof TEntity['fields'] | keyof TEntity['relations']]?: K extends keyof TEntity['relations'] ? TEntity['relations'][K] extends RelationDef ? TEntity['relations'][K]['entity'] extends keyof TDefs ? SelectInput<TDefs, TDefs[TEntity['relations'][K]['entity']]> : never : never : K extends keyof TEntity['fields'] ? true : never;
+};
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type InferResult<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect> = Simplify<InferScalars<TEntity, TSelect> & InferRelations<TDefs, TEntity, TSelect>>;
+type InferScalars<TEntity extends EntityDef, TSelect> = Pick<TEntity['fields'], keyof TSelect & keyof TEntity['fields']>;
+type InferRelations<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect> = {
+    [K in keyof TSelect & keyof TEntity['relations'] as TSelect[K] extends Record<string, unknown> ? K : never]: TEntity['relations'][K] extends RelationDef ? TEntity['relations'][K]['entity'] extends keyof TDefs ? TEntity['relations'][K]['type'] extends 'many' ? InferResult<TDefs, TDefs[TEntity['relations'][K]['entity']], TSelect[K]>[] : InferResult<TDefs, TDefs[TEntity['relations'][K]['entity']], TSelect[K]> | null : never : never;
+};
+export type ClientConfig<TSchema extends SchemaDescriptor = SchemaDescriptor> = {
+    url: string | (() => string);
+    schema: TSchema;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+};
+export {};