@drizzle-graphql-suite/client 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,236 @@
+# @drizzle-graphql-suite/client
+
+Type-safe GraphQL client auto-generated from Drizzle schemas, with full TypeScript inference for queries, mutations, filters, and relations.
+
+## Quick Start
+
+### 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 { createDrizzleClient } from 'drizzle-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 ...' },
+})
+```
+
+### From Schema Descriptor
+
+Use `createClient` with a codegen-generated schema descriptor when you want to decouple from the Drizzle schema at runtime (e.g., in a frontend bundle that shouldn't import server-side schema files).
+
+```ts
+import { createClient } from 'drizzle-graphql-suite/client'
+import { schema, type EntityDefs } from './generated/entity-defs'
+
+const client = createClient<typeof schema, EntityDefs>({
+  schema,
+  url: '/api/graphql',
+})
+```
+
+## EntityClient API
+
+Access a typed entity client via `client.entity('name')`:
+
+```ts
+const user = client.entity('user')
+```
+
+Each entity client provides the following methods:
+
+### `query(params)`
+
+Fetch a list of records with optional filtering, pagination, and ordering. Returns `T[]`.
+
+```ts
+const users = await user.query({
+  select: {
+    id: true,
+    name: true,
+    email: true,
+    posts: {
+      id: true,
+      title: true,
+      comments: { id: true, body: true },
+    },
+  },
+  where: { email: { ilike: '%@example.com' } },
+  orderBy: { name: { direction: 'asc', priority: 1 } },
+  limit: 20,
+  offset: 0,
+})
+```
+
+### `querySingle(params)`
+
+Fetch a single record. Returns `T | null`.
+
+```ts
+const found = await user.querySingle({
+  select: { id: true, name: true, email: true },
+  where: { id: { eq: 'some-uuid' } },
+})
+```
+
+### `count(params?)`
+
+Count matching records. Returns `number`.
+
+```ts
+const total = await user.count({
+  where: { role: { eq: 'admin' } },
+})
+```
+
+### `insert(params)`
+
+Insert multiple records. Returns `T[]` of inserted rows.
+
+```ts
+const created = await user.insert({
+  values: [
+    { name: 'Alice', email: 'alice@example.com' },
+    { name: 'Bob', email: 'bob@example.com' },
+  ],
+  returning: { id: true, name: true },
+})
+```
+
+### `insertSingle(params)`
+
+Insert a single record. Returns `T | null`.
+
+```ts
+const created = await user.insertSingle({
+  values: { name: 'Alice', email: 'alice@example.com' },
+  returning: { id: true, name: true },
+})
+```
+
+### `update(params)`
+
+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.
+
+```ts
+const deleted = await user.delete({
+  where: { deletedAt: { isNotNull: true } },
+  returning: { id: true },
+})
+```
+
+## 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
+import { buildSchemaDescriptor } from 'drizzle-graphql-suite/client'
+import * as schema from './db/schema'
+
+const descriptor = buildSchemaDescriptor(schema, {
+  suffixes: { list: 's' },
+  tables: { exclude: ['session'] },
+  pruneRelations: { 'user.sessions': false },
+})
+```
+
+Config options mirror the schema package: `mutations`, `suffixes`, `tables.exclude`, and `pruneRelations`.
+
+## 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 'drizzle-graphql-suite/client'
+import type * as schema from './db/schema'
+
+type MyEntityDefs = InferEntityDefs<typeof schema, { tables: { exclude: ['session'] } }>
+```
+
+### `InferResult<TDefs, TEntity, TSelect>`
+
+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.
+
+### `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()}`,
+  }),
+})
+```
+
+## Error Handling
+
+The client throws two error types:
+
+### `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 'drizzle-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 EntityClient } from './entity';
+import type { InferEntityDefs } from './infer';
+import { type ClientSchemaConfig } from './schema-builder';
+import type { AnyEntityDefs, ClientConfig, 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<TDefs, TDefs[TEntityName]>;
+    execute(query: string, variables?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+export type DrizzleClientConfig<TSchema extends Record<string, unknown>, TConfig extends ClientSchemaConfig> = {
+    schema: TSchema;
+    config: TConfig;
+    url: string | (() => string);
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+};
+export declare function createDrizzleClient<TSchema extends Record<string, unknown>, const TConfig extends ClientSchemaConfig>(options: DrizzleClientConfig<TSchema, TConfig>): GraphQLClient<SchemaDescriptor, InferEntityDefs<TSchema, TConfig>>;

package/entity.d.ts

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

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

@@ -0,0 +1,11 @@
+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 { DrizzleClientConfig } from './client';
+export { createDrizzleClient, GraphQLClient } from './client';
+export type { EntityClient } from './entity';
+export { GraphQLClientError, NetworkError } from './errors';
+export type { InferEntityDefs } from './infer';
+export type { ClientSchemaConfig } from './schema-builder';
+export { buildSchemaDescriptor } from './schema-builder';
+export type { AnyEntityDefs, ClientConfig, EntityDef, EntityDescriptor, InferResult, SchemaDescriptor, SelectInput, } from './types';

package/index.js

@@ -0,0 +1,439 @@
+// src/query-builder.ts
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function buildSelectionSet(select, schema, entityDef, indent = 4) {
+  const pad = " ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(select)) {
+    if (value === true) {
+      lines.push(`${pad}${key}`);
+      continue;
+    }
+    if (typeof value === "object" && value !== null) {
+      const rel = entityDef.relations[key];
+      if (!rel)
+        continue;
+      const targetDef = schema[rel.entity];
+      if (!targetDef)
+        continue;
+      const inner = buildSelectionSet(value, schema, targetDef, indent + 2);
+      lines.push(`${pad}${key} {`);
+      lines.push(inner);
+      lines.push(`${pad}}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function getFilterTypeName(entityName) {
+  return `${capitalize(entityName)}Filters`;
+}
+function getOrderByTypeName(entityName) {
+  return `${capitalize(entityName)}OrderBy`;
+}
+function getInsertInputTypeName(entityName) {
+  return `${capitalize(entityName)}InsertInput`;
+}
+function getUpdateInputTypeName(entityName) {
+  return `${capitalize(entityName)}UpdateInput`;
+}
+function buildListQuery(entityName, entityDef, schema, select, hasWhere, hasOrderBy, hasLimit, hasOffset) {
+  const opName = entityDef.queryListName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no list query`);
+  const filterType = getFilterTypeName(entityName);
+  const orderByType = getOrderByTypeName(entityName);
+  const operationName = `${capitalize(opName)}Query`;
+  const varDefs = [];
+  const argPairs = [];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  if (hasOrderBy) {
+    varDefs.push(`$orderBy: ${orderByType}`);
+    argPairs.push("orderBy: $orderBy");
+  }
+  if (hasLimit) {
+    varDefs.push("$limit: Int");
+    argPairs.push("limit: $limit");
+  }
+  if (hasOffset) {
+    varDefs.push("$offset: Int");
+    argPairs.push("offset: $offset");
+  }
+  const varDefsStr = varDefs.length ? `(${varDefs.join(", ")})` : "";
+  const argsStr = argPairs.length ? `(${argPairs.join(", ")})` : "";
+  const selection = buildSelectionSet(select, schema, entityDef);
+  const query = `query ${operationName}${varDefsStr} {
+  ${opName}${argsStr} {
+${selection}
+  }
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildSingleQuery(entityName, entityDef, schema, select, hasWhere, hasOrderBy, hasOffset) {
+  const opName = entityDef.queryName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no single query`);
+  const filterType = getFilterTypeName(entityName);
+  const orderByType = getOrderByTypeName(entityName);
+  const operationName = `${capitalize(opName)}SingleQuery`;
+  const varDefs = [];
+  const argPairs = [];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  if (hasOrderBy) {
+    varDefs.push(`$orderBy: ${orderByType}`);
+    argPairs.push("orderBy: $orderBy");
+  }
+  if (hasOffset) {
+    varDefs.push("$offset: Int");
+    argPairs.push("offset: $offset");
+  }
+  const varDefsStr = varDefs.length ? `(${varDefs.join(", ")})` : "";
+  const argsStr = argPairs.length ? `(${argPairs.join(", ")})` : "";
+  const selection = buildSelectionSet(select, schema, entityDef);
+  const query = `query ${operationName}${varDefsStr} {
+  ${opName}${argsStr} {
+${selection}
+  }
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildCountQuery(entityName, entityDef, hasWhere) {
+  const opName = entityDef.countName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no count query`);
+  const filterType = getFilterTypeName(entityName);
+  const operationName = `${capitalize(opName)}Query`;
+  const varDefs = [];
+  const argPairs = [];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  const varDefsStr = varDefs.length ? `(${varDefs.join(", ")})` : "";
+  const argsStr = argPairs.length ? `(${argPairs.join(", ")})` : "";
+  const query = `query ${operationName}${varDefsStr} {
+  ${opName}${argsStr}
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildInsertMutation(entityName, entityDef, schema, returning, isSingle) {
+  const opName = isSingle ? entityDef.insertSingleName : entityDef.insertName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no ${isSingle ? "insertSingle" : "insert"} mutation`);
+  const inputType = getInsertInputTypeName(entityName);
+  const operationName = `${capitalize(opName)}Mutation`;
+  const valuesType = isSingle ? `${inputType}!` : `[${inputType}!]!`;
+  const varDefs = `($values: ${valuesType})`;
+  const argsStr = "(values: $values)";
+  let selectionBlock = "";
+  if (returning) {
+    const selection = buildSelectionSet(returning, schema, entityDef);
+    selectionBlock = ` {
+${selection}
+  }`;
+  }
+  const query = `mutation ${operationName}${varDefs} {
+  ${opName}${argsStr}${selectionBlock}
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildUpdateMutation(entityName, entityDef, schema, returning, hasWhere) {
+  const opName = entityDef.updateName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no update mutation`);
+  const updateType = getUpdateInputTypeName(entityName);
+  const filterType = getFilterTypeName(entityName);
+  const operationName = `${capitalize(opName)}Mutation`;
+  const varDefs = [`$set: ${updateType}!`];
+  const argPairs = ["set: $set"];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  const varDefsStr = `(${varDefs.join(", ")})`;
+  const argsStr = `(${argPairs.join(", ")})`;
+  let selectionBlock = "";
+  if (returning) {
+    const selection = buildSelectionSet(returning, schema, entityDef);
+    selectionBlock = ` {
+${selection}
+  }`;
+  }
+  const query = `mutation ${operationName}${varDefsStr} {
+  ${opName}${argsStr}${selectionBlock}
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildDeleteMutation(entityName, entityDef, schema, returning, hasWhere) {
+  const opName = entityDef.deleteName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no delete mutation`);
+  const filterType = getFilterTypeName(entityName);
+  const operationName = `${capitalize(opName)}Mutation`;
+  const varDefs = [];
+  const argPairs = [];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  const varDefsStr = varDefs.length ? `(${varDefs.join(", ")})` : "";
+  const argsStr = argPairs.length ? `(${argPairs.join(", ")})` : "";
+  let selectionBlock = "";
+  if (returning) {
+    const selection = buildSelectionSet(returning, schema, entityDef);
+    selectionBlock = ` {
+${selection}
+  }`;
+  }
+  const query = `mutation ${operationName}${varDefsStr} {
+  ${opName}${argsStr}${selectionBlock}
+}`;
+  return { query, variables: {}, operationName };
+}
+
+// src/entity.ts
+function createEntityClient(entityName, entityDef, schema, executeGraphQL) {
+  return {
+    async query(params) {
+      const { select, where, limit, offset, orderBy } = params;
+      const built = buildListQuery(entityName, entityDef, schema, select, where != null, orderBy != null, limit != null, offset != null);
+      const variables = {};
+      if (where != null)
+        variables.where = where;
+      if (orderBy != null)
+        variables.orderBy = orderBy;
+      if (limit != null)
+        variables.limit = limit;
+      if (offset != null)
+        variables.offset = offset;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.queryListName];
+    },
+    async querySingle(params) {
+      const { select, where, offset, orderBy } = params;
+      const built = buildSingleQuery(entityName, entityDef, schema, select, where != null, orderBy != null, offset != null);
+      const variables = {};
+      if (where != null)
+        variables.where = where;
+      if (orderBy != null)
+        variables.orderBy = orderBy;
+      if (offset != null)
+        variables.offset = offset;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.queryName] ?? null;
+    },
+    async count(params) {
+      const where = params?.where;
+      const built = buildCountQuery(entityName, entityDef, where != null);
+      const variables = {};
+      if (where != null)
+        variables.where = where;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.countName];
+    },
+    async insert(params) {
+      const { values, returning } = params;
+      const built = buildInsertMutation(entityName, entityDef, schema, returning, false);
+      const variables = { values };
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.insertName];
+    },
+    async insertSingle(params) {
+      const { values, returning } = params;
+      const built = buildInsertMutation(entityName, entityDef, schema, returning, true);
+      const variables = { values };
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.insertSingleName] ?? null;
+    },
+    async update(params) {
+      const { set, where, returning } = params;
+      const built = buildUpdateMutation(entityName, entityDef, schema, returning, where != null);
+      const variables = { set };
+      if (where != null)
+        variables.where = where;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.updateName];
+    },
+    async delete(params) {
+      const { where, returning } = params;
+      const built = buildDeleteMutation(entityName, entityDef, schema, returning, where != null);
+      const variables = {};
+      if (where != null)
+        variables.where = where;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.deleteName];
+    }
+  };
+}
+
+// src/errors.ts
+class GraphQLClientError extends Error {
+  errors;
+  status;
+  constructor(errors, status = 200) {
+    const message = errors.map((e) => e.message).join("; ");
+    super(message);
+    this.name = "GraphQLClientError";
+    this.errors = errors;
+    this.status = status;
+  }
+}
+
+class NetworkError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "NetworkError";
+    this.status = status;
+  }
+}
+
+// src/schema-builder.ts
+import { getTableColumns, getTableName, is, Many, One, Relations, Table } from "drizzle-orm";
+var capitalize2 = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function buildSchemaDescriptor(schema, config = {}) {
+  const excludeSet = new Set(config.tables?.exclude ?? []);
+  const listSuffix = config.suffixes?.list ?? "s";
+  const tableMap = new Map;
+  const dbNameToKey = new Map;
+  for (const [key, value] of Object.entries(schema)) {
+    if (is(value, Table)) {
+      if (excludeSet.has(key))
+        continue;
+      const dbName = getTableName(value);
+      const cols = Object.keys(getTableColumns(value));
+      tableMap.set(key, { table: value, dbName, columns: cols });
+      dbNameToKey.set(dbName, key);
+    }
+  }
+  const relationsMap = new Map;
+  for (const value of Object.values(schema)) {
+    if (!is(value, Relations))
+      continue;
+    const sourceDbName = getTableName(value.table);
+    const sourceKey = dbNameToKey.get(sourceDbName);
+    if (!sourceKey || !tableMap.has(sourceKey))
+      continue;
+    const helpers = {
+      one: (referencedTable, cfg) => {
+        return new One(value.table, referencedTable, cfg, false);
+      },
+      many: (referencedTable, cfg) => {
+        return new Many(value.table, referencedTable, cfg);
+      }
+    };
+    const relConfig = value.config(helpers);
+    const rels = {};
+    for (const [relName, relValue] of Object.entries(relConfig)) {
+      const rel = relValue;
+      const targetDbName = rel.referencedTableName;
+      if (!targetDbName)
+        continue;
+      const targetKey = dbNameToKey.get(targetDbName);
+      if (!targetKey)
+        continue;
+      const type = is(rel, One) ? "one" : "many";
+      rels[relName] = { entity: targetKey, type };
+    }
+    relationsMap.set(sourceKey, rels);
+  }
+  const pruneRelations = config.pruneRelations ?? {};
+  for (const [sourceKey, rels] of relationsMap) {
+    for (const relName of Object.keys(rels)) {
+      const pruneKey = `${sourceKey}.${relName}`;
+      const pruneValue = pruneRelations[pruneKey];
+      if (pruneValue === false) {
+        delete rels[relName];
+      }
+    }
+  }
+  const descriptor = {};
+  for (const [key, { columns }] of tableMap) {
+    const rels = relationsMap.get(key) ?? {};
+    descriptor[key] = {
+      queryName: key,
+      queryListName: `${key}${listSuffix}`,
+      countName: `${key}Count`,
+      insertName: `insertInto${capitalize2(key)}`,
+      insertSingleName: `insertInto${capitalize2(key)}Single`,
+      updateName: `update${capitalize2(key)}`,
+      deleteName: `deleteFrom${capitalize2(key)}`,
+      fields: columns,
+      relations: rels
+    };
+  }
+  return descriptor;
+}
+
+// src/client.ts
+class GraphQLClient {
+  url;
+  schema;
+  headers;
+  constructor(config) {
+    this.url = config.url;
+    this.schema = config.schema;
+    this.headers = config.headers;
+  }
+  entity(entityName) {
+    const entityDef = this.schema[entityName];
+    if (!entityDef) {
+      throw new Error(`Entity '${entityName}' not found in schema`);
+    }
+    return createEntityClient(entityName, entityDef, this.schema, (query, variables) => this.execute(query, variables));
+  }
+  async execute(query, variables = {}) {
+    const url = typeof this.url === "function" ? this.url() : this.url;
+    const headers = {
+      "Content-Type": "application/json",
+      ...typeof this.headers === "function" ? await this.headers() : this.headers ?? {}
+    };
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ query, variables })
+      });
+    } catch (e) {
+      throw new NetworkError(e instanceof Error ? e.message : "Network request failed", 0);
+    }
+    if (!response.ok) {
+      throw new NetworkError(`HTTP ${response.status}: ${response.statusText}`, response.status);
+    }
+    const json = await response.json();
+    if (json.errors?.length) {
+      throw new GraphQLClientError(json.errors, response.status);
+    }
+    if (!json.data) {
+      throw new GraphQLClientError([{ message: "No data in response" }], response.status);
+    }
+    return json.data;
+  }
+}
+function createDrizzleClient(options) {
+  const schema = buildSchemaDescriptor(options.schema, options.config);
+  return new GraphQLClient({
+    url: options.url,
+    schema,
+    headers: options.headers
+  });
+}
+
+// src/index.ts
+function createClient(config) {
+  return new GraphQLClient(config);
+}
+export {
+  createDrizzleClient,
+  createClient,
+  buildSchemaDescriptor,
+  NetworkError,
+  GraphQLClientError,
+  GraphQLClient
+};

package/infer.d.ts

@@ -0,0 +1,86 @@
+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 _TNullable> ? {
+    entity: N;
+    type: 'one';
+} : 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 InferFilters<TFields> = {
+    [K in keyof TFields]?: ScalarFilterOps<NonNullable<TFields[K]>>;
+} & {
+    OR?: InferFilters<TFields>[];
+};
+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 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 ? {
+        entity: ResolveRelationEntity<TSchema, E>;
+        type: T;
+    } : TRels[K] : TRels[K];
+};
+type BuildEntityDef<TSchema, T> = T extends Table ? {
+    fields: WireFormat<T['$inferSelect']>;
+    relations: ResolveRelationDefs<TSchema, InferRelationDefs<TSchema, TableDbName<T>>>;
+    filters: InferFilters<WireFormat<T['$inferSelect']>>;
+    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]>;
+};
+export {};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@drizzle-graphql-suite/client",
+  "version": "0.5.0",
+  "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",
+    "directory": "packages/client"
+  },
+  "homepage": "https://github.com/annexare/drizzle-graphql-suite/tree/main/packages/client#readme",
+  "keywords": [
+    "drizzle",
+    "graphql",
+    "client",
+    "type-safe",
+    "typescript",
+    "orm",
+    "query-builder"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "peerDependencies": {
+    "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,15 @@
+import type { SchemaDescriptor } from './types';
+export type ClientSchemaConfig = {
+    mutations?: boolean;
+    suffixes?: {
+        list?: string;
+        single?: string;
+    };
+    tables?: {
+        exclude?: readonly string[];
+    };
+    pruneRelations?: Record<string, false | 'leaf' | {
+        only: string[];
+    }>;
+};
+export declare function buildSchemaDescriptor(schema: Record<string, unknown>, config?: ClientSchemaConfig): SchemaDescriptor;

package/types.d.ts

@@ -0,0 +1,45 @@
+export type RelationDef = {
+    entity: string;
+    type: 'one' | 'many';
+};
+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>;
+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 {};