---
title: Drizzle Objects
description: Defining GraphQL object types based on drizzle tables
---
Use the [configured builder](./setup) to map a Drizzle table to a GraphQL type. Defining a type
registers its fields; a root lookup makes them queryable.
## Defining Objects
The `builder.drizzleObject` method can be used to define GraphQL Object types based on a drizzle
table:
```ts
const User = builder.drizzleObject('users', {
name: 'User',
fields: (t) => ({
firstName: t.exposeString('firstName'),
lastName: t.exposeString('lastName'),
}),
});
```
You will be able to "expose" any column in the table, and GraphQL fields do not need to match the
names of the columns in your database. The returned `User` can be used like any other `ObjectRef`
in Pothos.
The example uses `builder.drizzleNode`, which adds a Relay ID and node refetching to the
same object API. See [Relay](./relay) for node IDs and refetching.
## Custom fields
A GraphQL field can combine several columns. The author’s full name declares both columns in
its selection and computes the string from the loaded row:
playground-examples/plugin-drizzle/types/user.ts#user-full-name
This field belongs in User's `fields` callback. With the default type selection, all scalar
columns are available; with `select: {}`, computed fields must declare what they read.
[Selections](./selections) explains when those columns and relations are loaded.
## Drizzle Fields
`t.drizzleField` can return a Drizzle object from Query or from any other object type. Its
resolver receives a `query` function before the usual resolver arguments. Call that function and
pass its result to `findFirst` or `findMany`: it merges your filters and ordering with the
requirements of the GraphQL selection.
### A nullable author lookup
The author page accepts an integer ID. A missing author returns null, matching the result of
`findFirst` and the field's `nullable: true` option:
playground-examples/plugin-drizzle/queries.ts#author-query
`author(id: 1) { fullName }` returns Maya Chen. `author(id: 999) { fullName }` returns null.
Adding `posts { title }` loads the public posts through the same root resolver.
For a list field, use `type: ['users']` and `db.query.users.findMany(query())`. A plain lookup
without arguments can pass no options to `query`; fields with filters pass those options to it.
If the `with` you pass to `query` names a relation the type's `select` also loads, the arguments
from the type's `select` are used for that relation.
### `drizzleFieldWithInput`
With the [with-input plugin](https://pothos-graphql.dev/docs/plugins/with-input),
`t.drizzleFieldWithInput` combines `t.drizzleField` with `t.fieldWithInput`. The `input` fields
become an input object argument, and the resolver still receives the `query` function as its first
argument. This alternative adds an `authorWithInput` lookup to the same public User type.
Install and register WithInputPlugin as described in [Setup](./setup#integration-with-other-plugins):
```ts
builder.queryFields((t) => ({
authorWithInput: t.drizzleFieldWithInput({
type: 'users',
nullable: true,
input: {
id: t.input.int({ required: true }),
},
resolve: (query, root, args, ctx) => {
return db.query.users.findFirst(
query({
where: { id: args.input.id },
}),
);
},
}),
}));
```
## Building a query from resolve info
Use `t.drizzleQueryFromInfo` inside a regular field resolver to combine its GraphQL selection
with Drizzle query options. Pass a table name or Drizzle object/interface ref, along with the
resolver's `context` and `info`. Pass the result directly to Drizzle:
```ts
builder.queryFields((t) => ({
user: t.field({
type: User,
nullable: true,
args: { id: t.arg.int({ required: true }) },
resolve: (_root, args, context, info) =>
db.query.users.findFirst(
t.drizzleQueryFromInfo('users', {
context,
info,
columns: { id: true },
where: { id: args.id },
}),
),
}),
}));
```
Pass `path: ['user']` when the resolver returns a payload containing a `user` field. `paths`
accepts multiple paths. Use a Drizzle ref instead of a table name to select a specific variant
of that table's GraphQL type.
The field builder checks the context and query options against its schema and table. Explicit
columns and relations retain their types; omitted columns are not statically guaranteed, even
if the GraphQL selection loads them. Put filters, selections, ordering, and limits inside the
helper call so they are merged with the planned selection.
With `AsyncSelections: true`, await the result before passing it to Drizzle:
```ts
resolve: async (_root, args, context, info) =>
db.query.users.findFirst(
await t.drizzleQueryFromInfo('users', {
context,
info,
where: { id: args.id },
}),
),
```
Without `AsyncSelections`, the helper is typed as synchronous, consistent with the schema's
selection callbacks. There is no per-call async option.