AI-Assisted Development with Axolotl

type Query {
  user(id: ID!): User @resolver
  posts(authorId: ID!, limit: Int = 10): [Post!]! @resolver
}
 
type User {
  id: ID!
  name: String!
  email: String!
}
 
type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
}

createResolvers({
  Query: {
    user: async ([source, args, context], { id }) => {
      // AI knows exactly what's available
      // - source: parent value
      // - args: field arguments (typed!)
      // - context: request context
      return db.users.findById(id);
    },
  },
});

// AI knows `id` is string, `limit` is number
// No guessing, no mistakes
posts: async ([, , ctx], { authorId, limit }) => {
  return db.posts.findMany({
    where: { authorId },
    take: limit,
  });
};

Implement the user resolver that:
1. Validates the id parameter
2. Fetches from database using Prisma
3. Handles not found errors
4. Returns User type matching schema

I have this GraphQL schema:
[paste schema]

Help me implement the user resolver with Axolotl

type AppContext = YogaInitialContext & {
  userId: string | null;
  db: PrismaClient;
};

Create Axolotl resolvers for a Todo type with:
- createTodo mutation (title, description)
- updateTodo mutation (id, title, description)
- deleteTodo mutation (id)
- todos query (list all)
- todo query (get by id)

Use Prisma for database access and include error handling.

Implement the createPost resolver that:
1. Checks if user is authenticated (ctx.userId)
2. Validates title and content
3. Creates post in database
4. Returns the created post
5. Throws GraphQLError if not authenticated

Create a User.posts resolver using DataLoader to:
1. Batch fetch posts by user ID
2. Cache results per request
3. Return empty array if no posts
4. Handle database errors gracefully

Add pagination to the posts query:
- cursor-based pagination
- limit parameter (default 10, max 100)
- return connection with edges and pageInfo
- include hasNextPage and endCursor

Enhance the users query with:
- filter by role (input type)
- search by name or email
- sort by createdAt (ASC/DESC)
- support multiple filters

Create an uploadAvatar mutation that:
- accepts a File scalar
- validates file type (jpg, png)
- uploads to S3
- updates user record with URL
- returns updated user

Context: [Describe your schema and setup]
Task: [What you want to build]
Requirements: [Specific needs]
Constraints: [Limitations or preferences]

1. Design your schema in schema.graphql
2. Run: npx @aexol/axolotl build
3. Ask AI: "Implement all @resolver fields"
4. Review and test generated code
5. Iterate on edge cases

1. Update schema with new types/fields
2. Run: npx @aexol/axolotl build
3. Ask AI: "Implement [new field] with [requirements]"
4. Add tests with AI assistance
5. Update documentation

1. Describe current code to AI
2. Ask: "Refactor this to use DataLoader"
3. Review changes
4. Run tests
5. Deploy incrementally

Generate tests for the createPost resolver:
- Test successful creation
- Test authentication failure
- Test validation errors
- Test database errors
- Use Node's test runner

Document this resolver with JSDoc:
- Describe what it does
- List parameters
- Describe return value
- Add usage example
- Note any side effects

Optimize this resolver for performance:
- Current: makes 3 DB queries
- Goal: reduce to 1 query
- Use: Prisma include
- Maintain: same return type

In Axolotl, resolvers use this signature:
(input, args) where input = [source, args, context]

type AppContext = YogaInitialContext & {
  userId: string | null;
  db: PrismaClient;
  loaders: {
    userById: DataLoader<string, User>;
  };
};

// Example pattern we use:
Query: {
  user: async ([, , ctx], { id }) => {
    if (!ctx.userId) throw new GraphQLError('Unauthorized');
    return ctx.db.user.findUnique({ where: { id } });
  };
}

I'm using Axolotl with graphqlYogaAdapter.
Please use createResolvers from axolotl.ts

Types are generated in src/models.ts
Import from there, don't create manual types

// Our setup in axolotl.ts
export const { createResolvers } = Axolotl(graphqlYogaWithContextAdapter<AppContext>(buildContext))<
  Models<Scalars>,
  Directives
>();

type Query {
  post(id: ID!): Post @resolver
  posts(filter: PostFilter, pagination: Pagination): PostConnection! @resolver
}
 
type Mutation {
  createPost(input: CreatePostInput!): Post! @resolver
  updatePost(id: ID!, input: UpdatePostInput!): Post! @resolver
  deletePost(id: ID!): Boolean! @resolver
}
 
type Post {
  id: ID!
  title: String!
  content: String!
  author: User! @resolver
  createdAt: String!
  updatedAt: String!
}
 
input CreatePostInput {
  title: String!
  content: String!
}
 
input UpdatePostInput {
  title: String
  content: String
}
 
input PostFilter {
  authorId: ID
  search: String
}
 
input Pagination {
  limit: Int = 10
  offset: Int = 0
}
 
type PostConnection {
  edges: [Post!]!
  totalCount: Int!
}

Implement all @resolver fields for the Post feature:

Context:
- Using Prisma with User and Post models
- AppContext has userId and db
- Need authentication for mutations
- Use DataLoader for Post.author

Requirements:
- Validate inputs
- Check auth on mutations
- Handle not found errors
- Use GraphQLError for errors
- Include JSDoc comments