Como crear una query en graphQL

Contexto

Se necesita crear una query que hace referencia al schema Foo que posee 3 atributos, los cuales son id, isActive y role. Para poder filtrar por foos activos e inactivos.

1. Revisar la tabla asociada al modelo

// /src/datasources/db/tables.ts
export const fooSchema = sqliteTable("foo", {
  id: text("id").primaryKey().notNull(),
  isActive: int("isActive", { mode: "boolean" }).default(true), 
  role: text("role", { enum: ["dev", "reviewer"] })
      .default("dev")
      .notNull(),
  ...createdAndUpdatedAtFields,
});

2. Verificar que esté instanciado los metodos de select e insert

// /src/datasource/db/CRUD.ts
import { createInsertSchema, createSelectSchema } from "drizzle-zod";
import { fooSchema } from "~/datasources/db/tables";

export const selectFooSchema = createSelectSchema(fooSchema);
export const insertFooSchema = createInsertSchema(fooSchema);

3. Verificar que este instanciada la referencia al modelo

// /src/schema/shared/refs.ts
import { z } from "zod";
import { builder } from "~/builder";
import { selectFooSchema } from "~/datasources/db/schema";

type FooGraphqlSchema = z.infer<typeof selectFooSchema>;
export const FooRef = builder.objectRef<FooGraphqlSchema>("Foo");

4. Verificar el schema asociado al modelo

// /src/schema/foo.ts
import {
  selectFooSchema,
} from "~/datasources/db/schema";

const FooRole = builder.enumType("FooRole", {
  values: ["dev", "reviewer"]
});

builder.objectType(FooRef, {
  description: "Representation of a foo",
  fields: (t) => ({
    id: t.exposeString("id", { nullable: false }),
    isActive: t.exposeBoolean("isActive", { nullable: false }),
    role: t.field({
      type: FooRole,
      nullable: false,
      resolve: (root) => root.role,
    }),
  });
});

5. Definir los campos necesarios para poder hacer la query

// /src/schema/foo.ts
const FooSearchInput = builder.inputType("FooSearchInput", {
  fields: (t) => ({
    isActive: t.field({ 
      type: "Boolean",
      required: false,
     }),
  }),
});

6. Definir la query foos en el schema

// /src/schema/foo.ts
builder.queryFields((t) => ({
  foos: t.field({
    type: [FooRef],
    args: {
      input: t.arg({ type: FooSearchInput, required: false }),
    },
    resolve: async (root, { input }, ctx) => {
      const { isActive } = input ?? {};
      const wheres: SQL[] = [];
      if (isActive) {
        wheres.push((foo) => foo.isActive === isActive);
      }
      const foos = await ctx.DB.query.fooSchema.findMany({
        where: (foo) => foo.and(...wheres),
      });
      return foos.map((foo) => selectFooSchema.parse(foo));
    },
  });
}));

Dentro del resolve vamos agregando querys al array de wheres, donde se filtran por atributos enviados en la query, para luego retornar los foos filtrados por el where