6. Deployment Considerations

• Containerization: Use Docker for all services to ensure consistent environments.
• Orchestration: Kubernetes for managing containerized applications, enabling scalability and high availability.
• Cloud Provider: AWS, Google Cloud, or Azure for hosting services, database, and storage.
• CI/CD Pipeline: Implement automated testing, building, and deployment using tools like GitHub Actions, GitLab CI, or Jenkins.
• Monitoring & Logging: Integrate with Prometheus/Grafana for monitoring, ELK stack/Loki for logging.

7. Scalability & Security

7.1. Scalability

• Microservices: Allows independent scaling of services (e.g., Code Generation Service can scale separately from Schema Management).
• Stateless Services: Design backend services to be stateless, enabling horizontal scaling.
• Database Scaling: Utilize PostgreSQL read replicas, sharding (if needed at extreme scale).
• Caching: Implement caching layers (e.g., Redis) for frequently accessed data like project metadata or schema ASTs.

7.2. Security

• Authentication: OAuth2, JWTs for API authentication.
• Authorization: Role-Based Access Control (RBAC) for project and schema access.
• Input Validation: Strict validation of all user inputs to prevent injection attacks.
• Data Encryption: Encrypt sensitive data at rest (database) and in transit (HTTPS/TLS).
• Vulnerability Scanning: Regularly scan dependencies and code for known vulnerabilities.
• Least Privilege: Grant services and users only the necessary permissions.

8. Integration Points

• Version Control Systems: GitHub, GitLab, Bitbucket.
• CI/CD Platforms: Jenkins, GitHub Actions, GitLab CI.
• Identity Providers: Okta, Auth0, Google, Azure AD.
• Documentation Generators: Swagger/OpenAPI (for REST equivalents), GraphQL Playground/GraphiQL (for schema docs).
• API Gateways: Apollo Federation, Hasura (for schema stitching/federation support).

Study Plan: Mastering GraphQL Schema Design

This study plan is designed for individuals looking to gain a deep understanding of GraphQL schema design principles, best practices, and advanced concepts. It is suitable for developers who will be using the GraphQL Schema Designer tool, contributing to its development, or designing GraphQL APIs in general.

1. Purpose & Learning Objectives

Purpose: To equip learners with the theoretical knowledge and practical skills required to design efficient, scalable, and maintainable GraphQL schemas.

Learning Objectives: Upon completion of this plan, participants will be able to:

• Understand the core concepts of GraphQL (Types, Fields, Queries, Mutations, Subscriptions).
• Design well-structured and intuitive GraphQL schemas using SDL.
• Apply best practices for schema evolution, versioning, and deprecation.
• Implement advanced schema features like directives, interfaces, unions, and enums.
• Identify and mitigate common GraphQL schema design pitfalls.
• Understand the relationship between schema design and resolver implementation.
• Utilize introspection and schema validation tools effectively.

2. Weekly Schedule

This is a 4-week intensive study plan, assuming 10-15 hours of study per week, including readings, exercises, and project work.

Week 1: Fundamentals of GraphQL & Basic Schema Design

• Learning Objectives:

* Grasp GraphQL's core principles and its advantages over REST.

* Understand Type System basics: Object Types, Scalar Types, Lists, Non-Nulls.

* Define Queries and their arguments.

* Write basic GraphQL SDL.

* Set up a simple GraphQL server and client.

• Topics:

* Introduction to GraphQL: Why GraphQL?

* The GraphQL Type System: Scalars, Objects, Fields, Arguments.

* Querying Data: Root Query Type, aliases, fragments, variables.

* Setting up a basic Apollo Server (Node.js) or Graphene (Python) project.

• Activities:

* Read official GraphQL documentation.

* Complete a "Hello World" GraphQL server.

* Design a simple schema for a blog (Posts, Authors).

* Write queries for the blog schema.

• Milestone: Successfully run a basic GraphQL server and execute queries against a simple schema.

Week 2: Mutations, Subscriptions & Advanced Types

• Learning Objectives:

* Implement Mutations for data modification.

* Understand Input Types for complex mutation arguments.

* Explore Subscriptions for real-time data.

* Utilize Interfaces and Union Types for polymorphic data.

* Define Enums for constrained values.

• Topics:

* Mutations: Design patterns, input types, payload types.

* Subscriptions: Real-time data, PubSub mechanisms.

* Interfaces: Abstract types, shared fields.

* Union Types: Returning different object types.

* Enums: Defining a set of allowed values.

* Custom Scalar Types (brief introduction).

• Activities:

* Add create/update/delete mutations to the blog schema.

* Implement a subscription for new posts.

* Refactor the schema to use interfaces (e.g., Node interface for global IDs).

* Define enums for post status (e.g., DRAFT, PUBLISHED).

• Milestone: Implement a full CRUD-like API with subscriptions using advanced type features.

Week 3: Schema Best Practices, Directives & Evolution

• Learning Objectives:

* Apply best practices for schema design (naming conventions, pagination, global IDs).

* Understand and use directives for schema annotations.

* Learn strategies for schema evolution (deprecating fields, adding new fields).

* Explore error handling patterns in GraphQL.

* Understand the role of data loaders for N+1 problem.

• Topics:

* Schema Design Principles: Naming, pagination (Connections spec), global object identification (Relay spec).

* Directives: @deprecated, @skip, @include, and custom

This deliverable outlines a comprehensive GraphQL schema design for a content management system (CMS) or blogging platform. It includes detailed type definitions, queries, mutations, subscriptions, a conceptual resolver strategy, and examples for client-side integration. This design is robust, scalable, and follows best practices for GraphQL API development.

GraphQL Schema Design: Content Management System

1. Introduction

This document provides a detailed GraphQL schema for a Content Management System (CMS). The schema is designed to manage users, posts, comments, categories, and tags. It leverages GraphQL's strong typing system to ensure data consistency and provides clear interfaces for querying, modifying, and subscribing to data changes.

2. GraphQL Schema Definition Language (SDL)

The following sections define the schema using GraphQL's Schema Definition Language (SDL).

2.1. Scalar Types

In addition to the built-in String, Int, Float, Boolean, and ID scalars, we define a custom DateTime scalar for handling date and time objects consistently.

# Custom scalar for representing a date and time, typically as an ISO 8601 string.
scalar DateTime

2.2. Enum Types

Enums provide a way to define a set of allowed values for a field.

# Represents the different roles a user can have within the system.
enum UserRole {
  ADMIN
  EDITOR
  AUTHOR
  SUBSCRIBER
}

# Represents the publication status of a post.
enum PostStatus {
  DRAFT
  PENDING_REVIEW
  PUBLISHED
  ARCHIVED
}

2.3. Interface Types

Interfaces define a set of fields that multiple object types can implement. This allows for polymorphism in queries.

# The Node interface is used for global object identification, commonly with Relay.
# It ensures every identifiable object has a unique ID.
interface Node {
  id: ID!
}

# The Timestamped interface ensures an object has creation and update timestamps.
interface Timestamped {
  createdAt: DateTime!
  updatedAt: DateTime!
}

2.4. Object Types

Object types are the fundamental building blocks of a GraphQL schema, representing the kinds of objects you can fetch from your service.

# Represents a user in the CMS.
type User implements Node & Timestamped {
  id: ID!
  username: String!
  email: String!
  firstName: String
  lastName: String
  role: UserRole!
  bio: String
  avatarUrl: String
  posts(limit: Int = 10, offset: Int = 0): [Post!]!
  comments(limit: Int = 10, offset: Int = 0): [Comment!]!
  createdAt: DateTime!
  updatedAt: DateTime!
}

# Represents a blog post.
type Post implements Node & Timestamped {
  id: ID!
  title: String!
  slug: String! # Unique URL-friendly identifier
  content: String!
  excerpt: String # Short summary of the post
  status: PostStatus!
  publishedAt: DateTime
  author: User!
  category: Category
  tags: [Tag!]!
  comments(limit: Int = 10, offset: Int = 0): [Comment!]!
  createdAt: DateTime!
  updatedAt: DateTime!
}

# Represents a comment made on a post.
type Comment implements Node & Timestamped {
  id: ID!
  content: String!
  author: User!
  post: Post!
  createdAt: DateTime!
  updatedAt: DateTime!
}

# Represents a category for organizing posts.
type Category implements Node & Timestamped {
  id: ID!
  name: String!
  slug: String! # Unique URL-friendly identifier
  description: String
  posts(limit: Int = 10, offset: Int = 0): [Post!]!
  createdAt: DateTime!
  updatedAt: DateTime!
}

# Represents a tag for categorizing posts.
type Tag implements Node & Timestamped {
  id: ID!
  name: String!
  slug: String! # Unique URL-friendly identifier
  posts(limit: Int = 10, offset: Int = 0): [Post!]!
  createdAt: DateTime!
  updatedAt: DateTime!
}

2.5. Input Types

Input types are special object types used as arguments for mutations. They allow you to pass complex objects as input.

# Input for creating a new user.
input CreateUserInput {
  username: String!
  email: String!
  password: String!
  firstName: String
  lastName: String
  role: UserRole = SUBSCRIBER # Default role
  bio: String
  avatarUrl: String
}

# Input for updating an existing user. All fields are optional.
input UpdateUserInput {
  username: String
  email: String
  password: String
  firstName: String
  lastName: String
  role: UserRole
  bio: String
  avatarUrl: String
}

# Input for creating a new post.
input CreatePostInput {
  title: String!
  content: String!
  excerpt: String
  authorId: ID!
  categoryId: ID
  tagIds: [ID!]
  status: PostStatus = DRAFT # Default status
  publishedAt: DateTime
}

# Input for updating an existing post. All fields are optional.
input UpdatePostInput {
  title: String
  content: String
  excerpt: String
  categoryId: ID
  tagIds: [ID!]
  status: PostStatus
  publishedAt: DateTime
}

# Input for creating a new comment.
input CreateCommentInput {
  content: String!
  authorId: ID!
  postId: ID!
}

# Input for creating a new category.
input CreateCategoryInput {
  name: String!
  description: String
}

# Input for updating an existing category. All fields are optional.
input UpdateCategoryInput {
  name: String
  description: String
}

# Input for creating a new tag.
input CreateTagInput {
  name: String!
}

# Input for updating an existing tag. All fields are optional.
input UpdateTagInput {
  name: String
}

# Input for filtering posts.
input PostFilterInput {
  authorId: ID
  categoryId: ID
  tagIds: [ID!]
  status: PostStatus
  search: String # Full-text search on title/content
  publishedBefore: DateTime
  publishedAfter: DateTime
}

# Input for sorting posts.
input PostSortInput {
  field: PostSortField!
  direction: SortDirection = ASC
}

enum PostSortField {
  CREATED_AT
  UPDATED_AT
  PUBLISHED_AT
  TITLE
}

enum SortDirection {
  ASC
  DESC
}

2.6. Query Type

The Query type defines all the entry points for reading data from your API.

# The root Query type defines all read operations available in the API.
type Query {
  # --- User Queries ---
  user(id: ID!): User
  users(limit: Int = 10, offset: Int = 0): [User!]!

  # --- Post Queries ---
  post(id: ID!): Post
  posts(
    filter: PostFilterInput
    sortBy: PostSortInput
    limit: Int = 10
    offset: Int = 0
  ): [Post!]!

  # --- Comment Queries ---
  comment(id: ID!): Comment
  commentsByPost(postId: ID!, limit: Int = 10, offset: Int = 0): [Comment!]!

  # --- Category Queries ---
  category(id: ID!): Category
  categories(limit: Int = 10, offset: Int = 0): [Category!]!

  # --- Tag Queries ---
  tag(id: ID!): Tag
  tags(limit: Int = 10, offset: Int = 0): [Tag!]!
}

2.7. Mutation Type

The Mutation type defines all the entry points for writing (creating, updating, deleting) data.

# The root Mutation type defines all write operations available in the API.
type Mutation {
  # --- User Mutations ---
  createUser(input: CreateUserInput!): User!
  updateUser(id: ID!, input: UpdateUserInput!): User
  deleteUser(id: ID!): Boolean! # Returns true if deletion was successful

  # --- Post Mutations ---
  createPost(input: CreatePostInput!): Post!
  updatePost(id: ID!, input: UpdatePostInput!): Post
  deletePost(id: ID!): Boolean!

  # --- Comment Mutations ---
  createComment(input: CreateCommentInput!): Comment!
  updateComment(id: ID!, content: String!): Comment # Only content can be updated
  deleteComment(id: ID!): Boolean!

  # --- Category Mutations ---
  createCategory(input: CreateCategoryInput!): Category!
  updateCategory(id: ID!, input: UpdateCategoryInput!): Category
  deleteCategory(id: ID!): Boolean!

  # --- Tag Mutations ---
  createTag(input: CreateTagInput!): Tag!
  updateTag(id: ID!, input: UpdateTagInput!): Tag
  deleteTag(id: ID!): Boolean!
}

2.8. Subscription Type

The Subscription type defines events that clients can subscribe to, receiving real-time updates when data changes.

# The root Subscription type defines all real-time event subscriptions.
type Subscription {
  # Notifies when a new post is created.
  newPost: Post!

  # Notifies when a new comment is added to a specific post.
  commentAdded(postId: ID!): Comment!

  # Notifies when any post's status changes (e.g., from DRAFT to PUBLISHED).
  postStatusChanged(postId: ID!): Post!
}

3. Resolver Implementation Strategy

Resolvers are functions that tell GraphQL how to fetch the data for a particular field. Each field in your schema (except for scalar types) needs a corresponding resolver function.

3.1. Resolver Map Structure

A typical GraphQL server (e.g., Apollo Server, GraphQL.js) organizes resolvers into a map that mirrors the schema structure.

// Conceptual Resolver Map Structure
const resolvers = {
  DateTime: new GraphQLScalarType({ /* ... implementation for scalar ... */ }),
  Node: {
    __resolveType(obj, context, info) {
      // Determine the concrete type of the Node based on the object's properties
      if (obj.username) return 'User';
      if (obj.title) return 'Post';
      // ... and so on for other types implementing Node
      return null;
    },
  },
  Timestamped: {
    __resolveType(obj, context, info) {
        // Determine the concrete type similarly to Node
        if (obj.username) return 'User';
        if (obj.title) return 'Post';
        // ...
        return null;
    }
  },
  Query: {
    user: async (parent, { id }, context) => {
      // Fetch user from database
      return context.dataSources.usersAPI.getUserById(id);
    },
    users: async (parent, { limit, offset }, context) => {
      // Fetch users from database with pagination
      return context.dataSources.usersAPI.getUsers(limit, offset);
    },
    posts: async (parent, { filter, sortBy, limit, offset }, context) => {
      // Fetch posts, apply filters, sorting, and pagination
      return context.dataSources.postsAPI.getPosts(filter, sortBy, limit, offset);
    },
    // ... other Query resolvers
  },
  Mutation: {
    createUser: async (parent, { input }, context) => {
      // Create user in database
      return context.dataSources.usersAPI.createUser(input);
    },
    updatePost: async (parent, { id, input }, context) => {
      // Update post in database
      return context.dataSources.postsAPI.updatePost(id, input);
    },
    // ... other Mutation resolvers
  },
  Subscription: {
    newPost: {
      subscribe: (parent, args, context) =>
        context.pubsub.asyncIterator(['NEW_POST']), // Use a PubSub system
    },
    commentAdded: {
      subscribe: (parent, { postId }, context) =>
        context.pubsub.asyncIterator([`COMMENT_ADDED_${postId}`]),
    },
    // ... other Subscription resolvers
  },
  User: {
    posts: async (parent, { limit, offset }, context) => {
      // Resolver for User.posts field. Parent is the User object.
      return context.dataSources.postsAPI.getPostsByAuthor(parent.id, limit, offset);
    },
    comments: async (parent, { limit, offset }, context) => {
      // Resolver for User.comments field
      return context.dataSources.commentsAPI.getCommentsByAuthor(parent.id, limit, offset);
    },
    // ... other User field resolvers
  },
  Post: {
    author: async (parent, args, context) => {
      // Resolver for Post.author field.

This document outlines a comprehensive GraphQL schema design for an e-commerce platform, covering types, queries, mutations, subscriptions, resolver examples, and integration guidance. This design emphasizes strong typing, flexibility, and extensibility to support a robust and scalable API.

1. Introduction to the GraphQL Schema Design

This deliverable provides a complete GraphQL schema blueprint, crafted to serve as the foundational API layer for a modern e-commerce application. It encompasses user management, product catalog, order processing, and review functionalities, demonstrating best practices for building a maintainable and performant GraphQL API.

2. Core Schema Design Principles

The design adheres to the following core principles:

• Strong Typing: Every piece of data has a clearly defined type, ensuring data consistency and enabling powerful tooling for development.
• Intuitiveness: The schema is designed to be easily understandable by both frontend and backend developers, mirroring the domain model.
• Flexibility & Extensibility: New features and data can be added without breaking existing clients, supporting long-term evolution.
• Efficiency: Queries are optimized to fetch only the necessary data, minimizing over-fetching and under-fetching issues common in REST APIs.
• Actionability: Mutations clearly define the actions that can be performed, and subscriptions enable real-time updates.

3. GraphQL Schema Definition Language (SDL)

Below is the complete GraphQL Schema Definition Language (SDL) for our e-commerce platform.

# Custom Scalars
scalar DateTime # Represents a date and time string in ISO 8601 format.
scalar JSON     # Represents arbitrary JSON data.

# Enums
enum UserRole {
  CUSTOMER
  ADMIN
  EDITOR
}

enum OrderStatus {
  PENDING
  PROCESSING
  SHIPPED
  DELIVERED
  CANCELLED
  RETURNED
}

# Object Types

type Address {
  street: String!
  city: String!
  state: String!
  zipCode: String!
  country: String!
}

type User {
  id: ID!
  username: String!
  email: String!
  firstName: String
  lastName: String
  role: UserRole!
  address: Address
  createdAt: DateTime!
  updatedAt: DateTime!
  orders: [Order!]!
  reviews: [Review!]!
}

type Category {
  id: ID!
  name: String!
  description: String
  products: [Product!]!
}

type Product {
  id: ID!
  name: String!
  description: String
  price: Float!
  imageUrl: String
  category: Category!
  stock: Int!
  reviews: [Review!]!
  createdAt: DateTime!
  updatedAt: DateTime!
}

type Review {
  id: ID!
  product: Product!
  user: User!
  rating: Int! # 1-5 stars
  comment: String
  createdAt: DateTime!
}

type OrderItem {
  id: ID!
  product: Product!
  quantity: Int!
  price: Float! # Price at the time of order
}

type Order {
  id: ID!
  user: User!
  items: [OrderItem!]!
  totalAmount: Float!
  status: OrderStatus!
  shippingAddress: Address!
  createdAt: DateTime!
  updatedAt: DateTime!
}

# Input Types (for Mutations)

input AddressInput {
  street: String!
  city: String!
  state: String!
  zipCode: String!
  country: String!
}

input CreateUserInput {
  username: String!
  email: String!
  password: String! # In a real app, handle securely (e.g., hash before storage)
  firstName: String
  lastName: String
  role: UserRole! = CUSTOMER # Default role
  address: AddressInput
}

input UpdateUserInput {
  id: ID!
  username: String
  email: String
  firstName: String
  lastName: String
  role: UserRole
  address: AddressInput
}

input CreateProductInput {
  name: String!
  description: String
  price: Float!
  imageUrl: String
  categoryId: ID!
  stock: Int!
}

input UpdateProductInput {
  id: ID!
  name: String
  description: String
  price: Float
  imageUrl: String
  categoryId: ID
  stock: Int
}

input CreateReviewInput {
  productId: ID!
  userId: ID!
  rating: Int!
  comment: String
}

input OrderItemInput {
  productId: ID!
  quantity: Int!
}

input CreateOrderInput {
  userId: ID!
  items: [OrderItemInput!]!
  shippingAddress: AddressInput!
}


# Root Query Type
type Query {
  # User Queries
  users(limit: Int = 10, offset: Int = 0): [User!]!
  user(id: ID!): User

  # Product Queries
  products(limit: Int = 10, offset: Int = 0, categoryId: ID, search: String): [Product!]!
  product(id: ID!): Product
  categories: [Category!]!
  category(id: ID!): Category

  # Order Queries
  orders(limit: Int = 10, offset: Int = 0, userId: ID, status: OrderStatus): [Order!]!
  order(id: ID!): Order

  # Review Queries
  reviews(productId: ID, userId: ID, limit: Int = 10, offset: Int = 0): [Review!]!
}

# Root Mutation Type
type Mutation {
  # User Mutations
  createUser(input: CreateUserInput!): User!
  updateUser(input: UpdateUserInput!): User!
  deleteUser(id: ID!): Boolean! # Returns true if deletion was successful

  # Product Mutations
  createProduct(input: CreateProductInput!): Product!
  updateProduct(input: UpdateProductInput!): Product!
  deleteProduct(id: ID!): Boolean!

  # Order Mutations
  createOrder(input: CreateOrderInput!): Order!
  updateOrderStatus(orderId: ID!, newStatus: OrderStatus!): Order!

  # Review Mutations
  createReview(input: CreateReviewInput!): Review!
}

# Root Subscription Type
type Subscription {
  orderStatusUpdated(orderId: ID!): Order! # Notifies when a specific order's status changes
  productAdded: Product! # Notifies when a new product is added to the catalog
}

4. Resolver Structure and Examples

Resolvers are functions that tell the GraphQL server how to fetch the data for a particular field. Each field in the schema (e.g., User.id, Query.users, Mutation.createUser) has a corresponding resolver function.

4.1 Resolver Signature

A resolver function typically has the signature: (parent, args, context, info) => data.

• parent: The result of the parent resolver. Useful for nested fields (e.g., User object for User.orders).
• args: An object containing all arguments provided to the field (e.g., id for user(id: ID!)).
• context: An object shared across all resolvers in a single request. Useful for passing database connections, authentication info, or data loaders.
• info: Contains information about the execution state of the query, including the field name, path to the field from the root, and the AST of the query.

4.2 Example Resolver Implementation (Node.js with Apollo Server)

Let's assume we have a dataSources object in our context that provides methods to interact with our database or other microservices.

// Example data sources (e.g., using a simple in-memory store or a database client)
const usersDB = [
  { id: '1', username: 'alice', email: 'alice@example.com', firstName: 'Alice', lastName: 'Smith', role: 'CUSTOMER', createdAt: new Date(), updatedAt: new Date(), address: { street: '123 Main St', city: 'Anytown', state: 'CA', zipCode: '90210', country: 'USA' } },
  { id: '2', username: 'bob', email: 'bob@example.com', firstName: 'Bob', lastName: 'Johnson', role: 'ADMIN', createdAt: new Date(), updatedAt: new Date(), address: { street: '456 Oak Ave', city: 'Otherville', state: 'NY', zipCode: '10001', country: 'USA' } }
];
const productsDB = [
  { id: 'p1', name: 'Laptop', description: 'Powerful laptop', price: 1200.00, imageUrl: 'laptop.jpg', categoryId: 'c1', stock: 50, createdAt: new Date(), updatedAt: new Date() },
  { id: 'p2', name: 'Mouse', description: 'Wireless mouse', price: 25.00, imageUrl: 'mouse.jpg', categoryId: 'c2', stock: 200, createdAt: new Date(), updatedAt: new Date() }
];
const categoriesDB = [
  { id: 'c1', name: 'Electronics', description: 'Gadgets and devices' },
  { id: 'c2', name: 'Peripherals', description: 'Computer accessories' }
];
const ordersDB = []; // In a real app, this would be a persistent store
const reviewsDB = []; // In a real app, this would be a persistent store

// A simple PubSub mechanism for subscriptions
const { PubSub } = require('graphql-subscriptions');
const pubsub = new PubSub();

// Event constants
const ORDER_STATUS_UPDATED = 'ORDER_STATUS_UPDATED';
const PRODUCT_ADDED = 'PRODUCT_ADDED';


const resolvers = {
  // Custom Scalar Resolvers
  DateTime: new GraphQLScalarType({
    name: 'DateTime',
    description: 'DateTime custom scalar type',
    serialize(value) {
      return value.toISOString(); // Convert outgoing Date to ISO string
    },
    parseValue(value) {
      return new Date(value); // Convert incoming ISO string to Date
    },
    parseLiteral(ast) {
      if (ast.kind === Kind.STRING) {
        return new Date(ast.value); // Convert AST string value to Date
      }
      return null;
    },
  }),
  JSON: new GraphQLScalarType({
    name: 'JSON',
    description: 'JSON custom scalar type',
    serialize(value) {
      return value;
    },
    parseValue(value) {
      return value;
    },
    parseLiteral(ast) {
      // Implement parsing for JSON literals if needed, e.g., using JSON.parse
      if (ast.kind === Kind.STRING) {
        return JSON.parse(ast.value);
      }
      return null;
    },
  }),

  // Type Resolvers (for nested fields)
  User: {
    orders: (parent, args, context) => {
      // Resolve orders associated with this user
      return ordersDB.filter(order => order.userId === parent.id);
    },
    reviews: (parent, args, context) => {
      // Resolve reviews made by this user
      return reviewsDB.filter(review => review.userId === parent.id);
    },
  },
  Product: {
    category: (parent, args, context) => {
      // Resolve the category for this product
      return categoriesDB.find(cat => cat.id === parent.categoryId);
    },
    reviews: (parent, args, context) => {
      // Resolve reviews for this product
      return reviewsDB.filter(review => review.productId === parent.id);
    },
  },
  Category: {
    products: (parent, args, context) => {
      // Resolve products belonging to this category
      return productsDB.filter(product => product.categoryId === parent.id);
    },
  },
  OrderItem: {
    product: (parent, args, context) => {
      // Resolve the product for this order item
      return productsDB.find(product => product.id === parent.productId);
    },
  },
  Order: {
    user: (parent, args, context) => {
      // Resolve the user who placed this order
      return usersDB.find(user => user.id === parent.userId);
    },
  },
  Review: {
    product: (parent, args, context) => {
      return productsDB.find(product => product.id === parent.productId);
    },
    user: (parent, args, context) => {
      return usersDB.find(user => user.id === parent.userId);
    },
  },

  // Root Query Resolvers
  Query: {
    users: (parent, { limit, offset