Naming

# Correct
type User { ... }
type BlogPost { ... }
type ShoppingCart { ... }
type PaymentMethod { ... }

# Incorrect
type user { ... }        # lowercase
type Users { ... }       # plural
type blog_post { ... }   # snake_case

interface Node { ... }
interface Timestamped { ... }
interface Searchable { ... }
interface Commentable { ... }

union SearchResult = User | Post | Comment
union MediaContent = Image | Video | Audio
union NotificationTarget = User | Group | Channel

type User {
  id: ID!
  firstName: String!
  lastName: String!
  emailAddress: String!
  createdAt: DateTime!
  isActive: Boolean!
}

type User {
  isActive: Boolean!
  isVerified: Boolean!
  hasSubscription: Boolean!
  canEdit: Boolean!
  shouldNotify: Boolean!
}

type Post {
  isPublished: Boolean!
  isArchived: Boolean!
  hasFeaturedImage: Boolean!
}

type User {
  posts: [Post!]!
  followers: [User!]!
  notifications: [Notification!]!
}

type Query {
  users: [User!]!
  allPosts: [Post!]!
}

type Post {
  author: User!         # Not: user, createdBy
  comments: [Comment!]!
  tags: [Tag!]!
}

type Comment {
  post: Post!           # Parent reference
  author: User!
  replies: [Comment!]!  # Child reference
}

type User {
  fullName: String!        # Not: getFullName, computedName
  postCount: Int!          # Not: calculatePostCount
  recentActivity: [Activity!]!
}

type Query {
  user(id: ID!): User
  users(first: Int, after: String): UserConnection!
  search(query: String!, filters: SearchFilters): [SearchResult!]!
}

# Single item lookup
user(id: ID!): User
post(slug: String!): Post

# Filtering
users(role: Role, isActive: Boolean): [User!]!

# Pagination
posts(first: Int, after: String): PostConnection!
posts(last: Int, before: String): PostConnection!

# Sorting
posts(orderBy: PostOrderBy): [Post!]!

# Search
search(query: String!): [SearchResult!]!

# Avoid
posts(filter: JSON)
users(options: Options)

# Prefer
posts(status: PostStatus, authorId: ID)
users(role: Role, createdAfter: DateTime)

enum UserRole { ... }
enum OrderStatus { ... }
enum SortDirection { ... }

enum UserRole {
  ADMIN
  MODERATOR
  MEMBER
  GUEST
}

enum OrderStatus {
  PENDING_PAYMENT
  PAYMENT_RECEIVED
  PROCESSING
  SHIPPED
  DELIVERED
  CANCELLED
  REFUNDED
}

enum SortDirection {
  ASC
  DESC
}

type Mutation {
  # Create operations
  createUser(input: CreateUserInput!): User!
  createPost(input: CreatePostInput!): Post!

  # Update operations
  updateUser(id: ID!, input: UpdateUserInput!): User!
  updatePost(id: ID!, input: UpdatePostInput!): Post!

  # Delete operations
  deleteUser(id: ID!): DeleteUserPayload!
  deletePost(id: ID!): DeletePostPayload!

  # Domain-specific operations
  publishPost(id: ID!): Post!
  archivePost(id: ID!): Post!

  sendMessage(input: SendMessageInput!): Message!

  addItemToCart(input: AddItemInput!): Cart!
  removeItemFromCart(itemId: ID!): Cart!

  followUser(userId: ID!): FollowPayload!
  unfollowUser(userId: ID!): UnfollowPayload!
}

input CreateUserInput {
  email: String!
  name: String!
}

input UpdateUserInput {
  email: String
  name: String
}

input SendMessageInput {
  recipientId: ID!
  body: String!
}

type DeleteUserPayload {
  success: Boolean!
  deletedUserId: ID
}

type FollowUserPayload {
  follower: User!
  followee: User!
}

# Avoid
type TUser { ... }
type UserType { ... }
strName: String!
intAge: Int!

# Prefer
type User { ... }
name: String!
age: Int!

# Avoid
type User {
  userId: ID!
  userName: String!
  userEmail: String!
}

# Prefer
type User {
  id: ID!
  name: String!
  email: String!
}

# Avoid
type User {
  mysql_id: Int!
  redis_cache_key: String!
  getDerivedStateFromProps: JSON!
}

# Prefer
type User {
  id: ID!
  # Internal details should not appear in schema
}

# Avoid
type Query {
  getData: JSON
  getInfo(type: String): JSON
  fetch(params: JSON): JSON
}

# Prefer
type Query {
  userProfile(userId: ID!): UserProfile
  orderHistory(first: Int): OrderConnection!
  searchProducts(query: String!): [Product!]!
}

# Avoid: inconsistent naming
type User {
  firstName: String!    # camelCase
  last_name: String!    # snake_case
  EmailAddress: String! # PascalCase
}

# Prefer: consistent camelCase
type User {
  firstName: String!
  lastName: String!
  emailAddress: String!
}