К основному содержанию
команда CX Codex

implement-graphql-api · davepoon — команда для Claude Code

Команда implement-graphql-api проводит агента по шагам сборки GraphQL API: сервер, схема, типы, курсорная пагинация и корневые Query с Mutation.

MIT ★ 3 785 обновлён 2026-10-25

Установить в Claude Code · Через маркетплейс плагинов Все способы и платформы ↓
/plugin marketplace add davepoon/buildwithclaude
/plugin install all-commands@buildwithclaude
Открыть на GitHub

Что делает implement-graphql-api

Команда ведёт агента по шагам: поднять GraphQL-сервер на Apollo Server или похожем решении, выбрать schema-first или code-first, описать типы, собрать корневые Query и Mutation. Внутри — каркас SDL со скалярами DateTime, EmailAddress, PhoneNumber, JSON, Upload, перечислениями ролей и статусов, типами User с вложенным профилем, Product с картинками и вариантами, Order с позициями и адресами.

Пагинация заложена курсорная: каждый список возвращает connection с edges, pageInfo и totalCount. Если в проекте привыкли к offset-пагинации, эти типы придётся переписать самому, потому что команда даёт один вариант. Входные типы CreateUserInput, UpdateUserInput, ProductFilters и CreateProductInput уже расписаны, значения по умолчанию стоят прямо в схеме: role: USER, status: DRAFT.

Мутации начинаются с авторизации: login, logout, refreshToken, forgotPassword. Дальше схему дописываете под свой домен — каркас задаёт структуру и связи, а не готовый бэкенд. Сервер поднимается на Apollo Server, так что этот пакет должен быть в проекте до первого шага.

Какие задачи решает

  • Собрать схему для товаров, заказов и адресов
  • Добавить курсорную пагинацию в список товаров
  • Описать входные типы для создания и обновления пользователя
  • Заложить мутации входа и обновления токена
  • Разметить кастомные скаляры под email и телефон

Примеры запросов агенту

  • Реализуй GraphQL API для каталога товаров: схема, типы, Query и Mutation
  • Собери схему GraphQL с курсорной пагинацией для заказов
  • Настрой Apollo Server и опиши SDL для пользователей и товаров

Как установить implement-graphql-api

1Через маркетплейс плагинов

/plugin marketplace add davepoon/buildwithclaude
/plugin install all-commands@buildwithclaude

2Вручную: положить файлы

.claude/commands/implement-graphql-api.md

Вызов — /implement-graphql-api. Для всех проектов — ~/.claude/commands/

Вопросы об implement-graphql-api

Как установить implement-graphql-api в Claude Code?

Добавьте маркетплейс командой /plugin marketplace add davepoon/buildwithclaude, затем поставьте плагин: /plugin install all-commands@buildwithclaude.

Что делает implement-graphql-api?

Помогает агенту пройти путь от настройки GraphQL-сервера до схемы с типами, входными типами и корневыми Query и Mutation.

Какая пагинация в схеме из команды?

Курсорная: списки возвращают connection-типы с edges, pageInfo и totalCount. Offset-вариант в каркасе не предусмотрен.

Исходный текст

implement-graphql-api.md · MIT
---
description: Implement GraphQL API endpoints
category: api-development
---

# Implement GraphQL API

Implement GraphQL API endpoints

## Instructions

1. **GraphQL Setup and Configuration**
   - Set up GraphQL server with Apollo Server or similar
   - Configure schema-first or code-first approach
   - Plan GraphQL architecture and data modeling
   - Set up development tools and introspection
   - Configure GraphQL playground and documentation

2. **Schema Definition and Type System**
   - Define comprehensive GraphQL schema:

   **Schema Definition (SDL):**
   ```graphql
   # schema/schema.graphql
   
   # Scalar types
   scalar DateTime
   scalar EmailAddress
   scalar PhoneNumber
   scalar JSON
   scalar Upload

   # User types and enums
   enum UserRole {
     USER
     ADMIN
     MANAGER
   }

   enum UserStatus {
     ACTIVE
     INACTIVE
     SUSPENDED
     PENDING_VERIFICATION
   }

   type User {
     id: ID!
     email: EmailAddress!
     username: String!
     firstName: String!
     lastName: String!
     fullName: String!
     phone: PhoneNumber
     dateOfBirth: DateTime
     avatar: String
     role: UserRole!
     status: UserStatus!
     emailVerified: Boolean!
     phoneVerified: Boolean!
     profile: UserProfile
     orders(
       first: Int = 10
       after: String
       status: OrderStatus
     ): OrderConnection!
     createdAt: DateTime!
     updatedAt: DateTime!
     lastLoginAt: DateTime
   }

   type UserProfile {
     bio: String
     website: String
     location: String
     timezone: String!
     language: String!
     notificationPreferences: JSON!
     privacySettings: JSON!
   }

   # Product types
   enum ProductStatus {
     DRAFT
     ACTIVE
     INACTIVE
     ARCHIVED
   }

   enum ProductVisibility {
     VISIBLE
     HIDDEN
     CATALOG_ONLY
     SEARCH_ONLY
   }

   type Product {
     id: ID!
     name: String!
     slug: String!
     sku: String!
     description: String
     shortDescription: String
     price: Float!
     comparePrice: Float
     costPrice: Float
     weight: Float
     dimensions: ProductDimensions
     category: Category
     brand: Brand
     vendor: Vendor
     status: ProductStatus!
     visibility: ProductVisibility!
     inventoryTracking: Boolean!
     inventoryQuantity: Int
     lowStockThreshold: Int
     allowBackorder: Boolean!
     requiresShipping: Boolean!
     isDigital: Boolean!
     featured: Boolean!
     tags: [String!]!
     attributes: JSON!
     images: [ProductImage!]!
     variants: [ProductVariant!]!
     reviews(
       first: Int = 10
       after: String
       rating: Int
     ): ReviewConnection!
     averageRating: Float
     reviewCount: Int!
     createdAt: DateTime!
     updatedAt: DateTime!
     publishedAt: DateTime
   }

   type ProductDimensions {
     length: Float
     width: Float
     height: Float
     unit: String!
   }

   type ProductImage {
     id: ID!
     url: String!
     altText: String
     sortOrder: Int!
   }

   type ProductVariant {
     id: ID!
     sku: String!
     price: Float!
     comparePrice: Float
     inventoryQuantity: Int
     attributes: JSON!
     image: ProductImage
   }

   # Order types
   enum OrderStatus {
     PENDING
     PROCESSING
     SHIPPED
     DELIVERED
     CANCELLED
     REFUNDED
     ON_HOLD
   }

   type Order {
     id: ID!
     orderNumber: String!
     user: User
     status: OrderStatus!
     currency: String!
     subtotal: Float!
     taxTotal: Float!
     shippingTotal: Float!
     discountTotal: Float!
     total: Float!
     billingAddress: Address!
     shippingAddress: Address!
     shippingMethod: String
     trackingNumber: String
     items: [OrderItem!]!
     notes: String
     createdAt: DateTime!
     updatedAt: DateTime!
     shippedAt: DateTime
     deliveredAt: DateTime
   }

   type OrderItem {
     id: ID!
     product: Product!
     productVariant: ProductVariant
     quantity: Int!
     unitPrice: Float!
     totalPrice: Float!
     productName: String!
     productSku: String!
     productAttributes: JSON
   }

   type Address {
     firstName: String!
     lastName: String!
     company: String
     addressLine1: String!
     addressLine2: String
     city: String!
     state: String
     postalCode: String!
     country: String!
     phone: PhoneNumber
   }

   # Connection types for pagination
   type UserConnection {
     edges: [UserEdge!]!
     pageInfo: PageInfo!
     totalCount: Int!
   }

   type UserEdge {
     node: User!
     cursor: String!
   }

   type ProductConnection {
     edges: [ProductEdge!]!
     pageInfo: PageInfo!
     totalCount: Int!
   }

   type ProductEdge {
     node: Product!
     cursor: String!
   }

   type OrderConnection {
     edges: [OrderEdge!]!
     pageInfo: PageInfo!
     totalCount: Int!
   }

   type OrderEdge {
     node: Order!
     cursor: String!
   }

   type PageInfo {
     hasNextPage: Boolean!
     hasPreviousPage: Boolean!
     startCursor: String
     endCursor: String
   }

   # Input types
   input CreateUserInput {
     email: EmailAddress!
     password: String!
     firstName: String!
     lastName: String!
     phone: PhoneNumber
     dateOfBirth: DateTime
     role: UserRole = USER
   }

   input UpdateUserInput {
     email: EmailAddress
     firstName: String
     lastName: String
     phone: PhoneNumber
     dateOfBirth: DateTime
     status: UserStatus
   }

   input ProductFilters {
     category: ID
     brand: ID
     priceMin: Float
     priceMax: Float
     status: ProductStatus
     featured: Boolean
     inStock: Boolean
     tags: [String!]
     search: String
   }

   input CreateProductInput {
     name: String!
     slug: String!
     sku: String!
     description: String
     price: Float!
     comparePrice: Float
     categoryId: ID
     brandId: ID
     status: ProductStatus = DRAFT
     inventoryQuantity: Int = 0
     attributes: JSON
     tags: [String!]
   }

   # Root types
   type Query {
     # User queries
     me: User
     user(id: ID!): User
     users(
       first: Int = 10
       after: String
       search: String
       role: UserRole
       status: UserStatus
     ): UserConnection!

     # Product queries
     product(id: ID, slug: String): Product
     products(
       first: Int = 10
       after: String
       filters: ProductFilters
       sortBy: ProductSortBy = CREATED_AT
       sortOrder: SortOrder = DESC
     ): ProductConnection!

     # Order queries
     order(id: ID!): Order
     orders(
       first: Int = 10
       after: String
       status: OrderStatus
       userId: ID
     ): OrderConnection!

     # Search
     search(
       query: String!
       first: Int = 10
       after: String
       types: [SearchType!] = [USER, PRODUCT, ORDER]
     ): SearchConnection!
   }

   type Mutation {
     # Auth mutations
     login(email: EmailAddress!, password: String!): AuthPayload!
     logout: Boolean!
     refreshToken: AuthPayload!
     forgotPassword(email: EmailAddress!): Boolean!
     resetPassword(token: String!, password: String!): AuthPayload!

     # User mutations
     createUser(input: CreateUserInput!): User!
     updateUser(id: ID!, input: UpdateUserInput!): User!
     deleteUser(id: ID!): Boolean!
     updateProfile(input: UpdateProfileInput!): UserProfile!

     # Product mutations
     createProduct(input: CreateProductInput!): Product!
     updateProduct(id: ID!, input: UpdateProductInput!): Product!
     deleteProduct(id: ID!): Boolean!
     uploadProductImage(productId: ID!, file: Upload!): ProductImage!

     # Order mutations
     createOrder(input: CreateOrderInput!): Order!
     updateOrderStatus(id: ID!, status: OrderStatus!): Order!
     addOrderItem(orderId: ID!, input: AddOrderItemInput!): OrderItem!
     removeOrderItem(id: ID!): Boolean!
   }

   type Subscription {
     # Real-time updates
     orderUpdated(userId: ID): Order!
     productUpdated(productId: ID): Product!
     userStatusChanged(userId: ID): User!
     
     # Admin subscriptions
     newOrder: Order!
     lowStockAlert: Product!
   }

   enum ProductSortBy {
     CREATED_AT
     NAME
     PRICE
     RATING
     POPULARITY
   }

   enum SortOrder {
     ASC
     DESC
   }

   enum SearchType {
     USER
     PRODUCT
     ORDER
   }

   type AuthPayload {
     token: String!
     refreshToken: String!
     user: User!
     expiresAt: DateTime!
   }
   ```

3. **Resolver Implementation**
   - Implement comprehensive resolvers:

   **Main Resolvers:**
   ```javascript
   // resolvers/index.js
   const { GraphQLDateTime } = require('graphql-iso-date');
   const { GraphQLEmailAddress, GraphQLPhoneNumber } = require('graphql-scalars');
   const GraphQLJSON = require('graphql-type-json');
   const GraphQLUpload = require('graphql-upload/GraphQLUpload.js');

   const userResolvers = require('./userResolvers');
   const productResolvers = require('./productResolvers');
   const orderResolvers = require('./orderResolvers');
   const searchResolvers = require('./searchResolvers');

   const resolvers = {
     // Custom scalars
     DateTime: GraphQLDateTime,
     EmailAddress: GraphQLEmailAddress,
     PhoneNumber: GraphQLPhoneNumber,
     JSON: GraphQLJSON,
     Upload: GraphQLUpload,

     // Root resolvers
     Query: {
       ...userResolvers.Query,
       ...productResolvers.Query,
       ...orderResolvers.Query,
       ...searchResolvers.Query
     },

     Mutation: {
       ...userResolvers.Mutation,
       ...productResolvers.Mutation,
       ...orderResolvers.Mutation
     },

     Subscription: {
       ...userResolvers.Subscription,
       ...productResolvers.Subscription,
       ...orderResolvers.Subscription
     },

     // Type resolvers
     User: userResolvers.User,
     Product: productResolvers.Product,
     Order: orderResolvers.Order
   };

   module.exports = resolvers;
   ```

   **User Resolvers:**
   ```javascript
   // resolvers/userResolvers.js
   const { AuthenticationError, ForbiddenError, UserInputError } = require('apollo-server-express');
   const { withFilter } = require('graphql-subscriptions');
   const userService = require('../services/userService');
   const { requireAuth, requireRole } = require('../utils/authHelpers');
   const { createConnectionFromArray } = require('../utils/connectionHelpers');

   const userResolvers = {
     Query: {
       async me(parent, args, context) {
         requireAuth(context);
         return await userService.findById(context.user.id);
       },

       async user(parent, { id }, context) {
         requireAuth(context);
         
         const user = await userService.findById(id);
         if (!user) {
           throw new UserInputError('User not found');
         }

         // Privacy check - users can only see their own data unless admin
         if (context.user.id !== user.id && !['admin', 'manager'].includes(context.user.role)) {
           throw new ForbiddenError('Insufficient permissions');
         }

         return user;
       },

       async users(parent, { first, after, search, role, status }, context) {
         requireAuth(context);
         requireRole(context, ['admin', 'manager']);

         const result = await userService.findUsers({
           first,
           after,
           search,
           role,
           status
         });

         return createConnectionFromArray(result.users, {
           first,
           after,
           totalCount: result.totalCount
         });
       }
     },

     Mutation: {
       async createUser(parent, { input }, context) {
         requireAuth(context);
         requireRole(context, ['admin']);

         // Check for existing user
         const existingUser = await userService.findByEmail(input.email);
         if (existingUser) {
           throw new UserInputError('User with this email already exists');
         }

         const user = await userService.createUser(input);
         
         // Publish subscription for real-time updates
         context.pubsub.publish('USER_CREATED', { userCreated: user });
         
         return user;
       },

       async updateUser(parent, { id, input }, context) {
         requireAuth(context);
         
         const existingUser = await userService.findById(id);
         if (!existingUser) {
           throw new UserInputError('User not found');
         }

         // Authorization check
         if (context.user.id !== id && !['admin', 'manager'].includes(context.user.role)) {
           throw new ForbiddenError('Insufficient permissions');
         }

         // Role change restriction
         if (input.role && !['admin'].includes(context.user.role)) {
           throw new ForbiddenError('Insufficient permissions to change user role');
         }

         const updatedUser = await userService.updateUser(id, input);
         
         // Publish subscription
         context.pubsub.publish('USER_UPDATED', { userUpdated: updatedUser });
         
         return updatedUser;
       },

       async deleteUser(parent, { id }, context) {
         requireAuth(context);
         requireRole(context, ['admin']);

         // Prevent self-deletion
         if (context.user.id === id) {
           throw new UserInputError('Cannot delete your own account');
         }

         const existingUser = await userService.findById(id);
         if (!existingUser) {
           throw new UserInputError('User not found');
         }

         await userService.deleteUser(id);
         
         // Publish subscription
         context.pubsub.publish('USER_DELETED', { userDeleted: existingUser });
         
         return true;
       }
     },

     Subscription: {
       userStatusChanged: {
         subscribe: withFilter(
           (parent, args, context) => {
             requireAuth(context);
             return context.pubsub.asyncIterator(['USER_UPDATED']);
           },
           (payload, variables) => {
             // Filter by userId if provided
             return !variables.userId || payload.userUpdated.id === variables.userId;
           }
         )
       }
     },

     // Field resolvers
     User: {
       fullName(parent) {
         return `${parent.firstName} ${parent.lastName}`;
       },

       async profile(parent, args, context) {
         return await userService.getUserProfile(parent.id);
       },

       async orders(parent, { first, after, status }, context) {
         requireAuth(context);
         
         // Users can only see their own orders unless admin
         if (context.user.id !== parent.id && !['admin', 'manager'].includes(context.user.role)) {
           throw new ForbiddenError('Insufficient permissions');
         }

         const result = await userService.getUserOrders(parent.id, {
           first,
           after,
           status
         });

         return createConnectionFromArray(result.orders, {
           first,
           after,
           totalCount: result.totalCount
         });
       }
     }
   };

   module.exports = userResolvers;
   ```

4. **DataLoader for N+1 Problem**
   - Implement efficient data loading:

   **DataLoader Implementation:**
   ```javascript
   // dataLoaders/index.js
   const DataLoader = require('dataloader');
   const userService = require('../services/userService');
   const productService = require('../services/productService');
   const orderService = require('../services/orderService');

   class DataLoaders {
     constructor() {
       this.userLoader = new DataLoader(
         async (userIds) => {
           const users = await userService.findByIds(userIds);
           return userIds.map(id => users.find(user => user.id === id) || null);
         },
         {
           cacheKeyFn: (key) => key.toString(),
           maxBatchSize: 100
         }
       );

       this.userProfileLoader = new DataLoader(
         async (userIds) => {
           const profiles = await userService.getProfilesByUserIds(userIds);
           return userIds.map(id => profiles.find(profile => profile.userId === id) || null);
         }
       );

       this.productLoader = new DataLoader(
         async (productIds) => {
           const products = await productService.findByIds(productIds);
           return productIds.map(id => products.find(product => product.id === id) || null);
         }
       );

       this.productCategoryLoader = new DataLoader(
         async (categoryIds) => {
           const categories = await productService.getCategoriesByIds(categoryIds);
           return categoryIds.map(id => categories.find(category => category.id === id) || null);
         }
       );

       this.productImagesLoader = new DataLoader(
         async (productIds) => {
           const imagesMap = await productService.getImagesByProductIds(productIds);
           return productIds.map(id => imagesMap[id] || []);
         }
       );

       this.orderItemsLoader = new DataLoader(
         async (orderIds) => {
           const itemsMap = await orderService.getItemsByOrderIds(orderIds);
           return orderIds.map(id => itemsMap[id] || []);
         }
       );

       this.productReviewsLoader = new DataLoader(
         async (productIds) => {
           const reviewsMap = await productService.getReviewsByProductIds(productIds);
           return productIds.map(id => reviewsMap[id] || []);
         }
       );
     }

     // Clear all caches
     clearAll() {
       this.userLoader.clearAll();
       this.userProfileLoader.clearAll();
       this.productLoader.clearAll();
       this.productCategoryLoader.clearAll();
       this.productImagesLoader.clearAll();
       this.orderItemsLoader.clearAll();
       this.productReviewsLoader.clearAll();
     }

     // Clear specific cache
     clearUser(userId) {
       this.userLoader.clear(userId);
       this.userProfileLoader.clear(userId);
     }

     clearProduct(productId) {
       this.productLoader.clear(productId);
       this.productImagesLoader.clear(productId);
       this.productReviewsLoader.clear(productId);
     }
   }

   module.exports = DataLoaders;
   ```

5. **Authentication and Authorization**
   - Implement GraphQL-specific auth:

   **Auth Helpers:**
   ```javascript
   // utils/authHelpers.js
   const { AuthenticationError, ForbiddenError } = require('apollo-server-express');
   const jwt = require('jsonwebtoken');
   const userService = require('../services/userService');

   class GraphQLAuth {
     static async getUser(req) {
       const authHeader = req.headers.authorization;
       
       if (!authHeader) {
         return null;
       }

       const token = authHeader.replace('Bearer ', '');
       
       try {
         const decoded = jwt.verify(token, process.env.JWT_SECRET);
         const user = await userService.findById(decoded.userId);
         
         if (!user || user.status !== 'active') {
           return null;
         }

         return user;
       } catch (error) {
         return null;
       }
     }

     static requireAuth(context) {
       if (!context.user) {
         throw new AuthenticationError('Authentication required');
       }
       return context.user;
     }

     static requireRole(context, roles) {
       this.requireAuth(context);
       
       if (!roles.includes(context.user.role)) {
         throw new ForbiddenError(`Requires one of the following roles: ${roles.join(', ')}`);
       }
       
       return context.user;
     }

     static requirePermission(context, permissions) {
       this.requireAuth(context);
       
       const userPermissions = context.user.permissions || [];
       const hasPermission = permissions.some(permission => 
         userPermissions.includes(permission)
       );
       
       if (!hasPermission) {
         throw new ForbiddenError(`Requires one of the following permissions: ${permissions.join(', ')}`);
       }
       
       return context.user;
     }

     static canAccessResource(context, resourceUserId, adminRoles = ['admin', 'manager']) {
       this.requireAuth(context);
       
       const isOwner = context.user.id === resourceUserId;
       const isAdmin = adminRoles.includes(context.user.role);
       
       if (!isOwner && !isAdmin) {
         throw new ForbiddenError('Insufficient permissions to access this resource');
       }
       
       return context.user;
     }
   }

   // Export individual functions for convenience
   const { requireAuth, requireRole, requirePermission, canAccessResource } = GraphQLAuth;

   module.exports = {
     GraphQLAuth,
     requireAuth,
     requireRole,
     requirePermission,
     canAccessResource
   };
   ```

6. **Real-time Subscriptions**
   - Implement GraphQL subscriptions:

   **Subscription Setup:**
   ```javascript
   // subscriptions/index.js
   const { PubSub } = require('graphql-subscriptions');
   const { RedisPubSub } = require('graphql-redis-subscriptions');
   const Redis = require('ioredis');

   // Use Redis for production, in-memory for development
   const createPubSub = () => {
     if (process.env.NODE_ENV === 'production') {
       const redisClient = new Redis(process.env.REDIS_URL);
       return new RedisPubSub({
         publisher: redisClient,
         subscriber: redisClient.duplicate()
       });
     } else {
       return new PubSub();
     }
   };

   const pubsub = createPubSub();

   // Subscription events
   const SUBSCRIPTION_EVENTS = {
     USER_CREATED: 'USER_CREATED',
     USER_UPDATED: 'USER_UPDATED',
     USER_DELETED: 'USER_DELETED',
     ORDER_CREATED: 'ORDER_CREATED',
     ORDER_UPDATED: 'ORDER_UPDATED',
     PRODUCT_UPDATED: 'PRODUCT_UPDATED',
     LOW_STOCK_ALERT: 'LOW_STOCK_ALERT'
   };

   // Subscription resolvers
   const subscriptionResolvers = {
     orderUpdated: {
       subscribe: (parent, { userId }, context) => {
         requireAuth(context);
         
         // Users can only subscribe to their own orders unless admin
         if (userId && context.user.id !== userId && !['admin', 'manager'].includes(context.user.role)) {
           throw new ForbiddenError('Insufficient permissions');
         }
         
         return pubsub.asyncIterator([SUBSCRIPTION_EVENTS.ORDER_UPDATED]);
       },
       resolve: (payload, { userId }) => {
         // Filter by userId if provided
         if (userId && payload.orderUpdated.userId !== userId) {
           return null;
         }
         return payload.orderUpdated;
       }
     },

     productUpdated: {
       subscribe: (parent, { productId }, context) => {
         return pubsub.asyncIterator([SUBSCRIPTION_EVENTS.PRODUCT_UPDATED]);
       },
       resolve: (payload, { productId }) => {
         // Filter by productId if provided
         if (productId && payload.productUpdated.id !== productId) {
           return null;
         }
         return payload.productUpdated;
       }
     },

     userStatusChanged: {
       subscribe: (parent, { userId }, context) => {
         requireAuth(context);
         requireRole(context, ['admin', 'manager']);
         
         return pubsub.asyncIterator([SUBSCRIPTION_EVENTS.USER_UPDATED]);
       },
       resolve: (payload, { userId }) => {
         if (userId && payload.userUpdated.id !== userId) {
           return null;
         }
         return payload.userUpdated;
       }
     },

     newOrder: {
       subscribe: (parent, args, context) => {
         requireAuth(context);
         requireRole(context, ['admin', 'manager']);
         
         return pubsub.asyncIterator([SUBSCRIPTION_EVENTS.ORDER_CREATED]);
       }
     },

     lowStockAlert: {
       subscribe: (parent, args, context) => {
         requireAuth(context);
         requireRole(context, ['admin', 'manager']);
         
         return pubsub.asyncIterator([SUBSCRIPTION_EVENTS.LOW_STOCK_ALERT]);
       }
     }
   };

   module.exports = {
     pubsub,
     SUBSCRIPTION_EVENTS,
     subscriptionResolvers
   };
   ```

7. **Error Handling and Validation**
   - Implement comprehensive error handling:

   **Error Handling:**
   ```javascript
   // utils/errorHandling.js
   const { 
     ApolloError, 
     AuthenticationError, 
     ForbiddenError, 
     UserInputError 
   } = require('apollo-server-express');

   class GraphQLErrorHandler {
     static handleError(error, operation) {
       // Log error for debugging
       console.error('GraphQL Error:', {
         message: error.message,
         operation: operation?.operationName,
         variables: operation?.variables,
         stack: error.stack
       });

       // Database errors
       if (error.code === '23505') { // Unique constraint violation
         return new UserInputError('A record with this information already exists');
       }
       
       if (error.code === '23503') { // Foreign key constraint violation
         return new UserInputError('Referenced record does not exist');
       }

       // Validation errors
       if (error.name === 'ValidationError') {
         const messages = Object.values(error.errors).map(err => err.message);
         return new UserInputError('Validation failed', {
           validationErrors: messages
         });
       }

       // Permission errors
       if (error.message.includes('permission') || error.message.includes('access')) {
         return new ForbiddenError(error.message);
       }

       // Authentication errors
       if (error.message.includes('token') || error.message.includes('auth')) {
         return new AuthenticationError(error.message);
       }

       // Network/external service errors
       if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
         return new ApolloError('External service unavailable', 'SERVICE_UNAVAILABLE');
       }

       // Default to internal error
       return new ApolloError(
         'An unexpected error occurred',
         'INTERNAL_ERROR',
         { originalError: error.message }
       );
     }

     static formatError(error) {
       // Don't expose internal errors in production
       if (process.env.NODE_ENV === 'production' && !error.extensions?.code) {
         return new ApolloError('Internal server error', 'INTERNAL_ERROR');
       }

       // Add request ID for tracking
       if (error.extensions?.requestId) {
         error.extensions.requestId = error.extensions.requestId;
       }

       return error;
     }
   }

   // Input validation helper
   class InputValidator {
     static validateEmail(email) {
       const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
       if (!emailRegex.test(email)) {
         throw new UserInputError('Invalid email format');
       }
     }

     static validatePassword(password) {
       if (password.length < 8) {
         throw new UserInputError('Password must be at least 8 characters long');
       }
       
       if (!/(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/.test(password)) {
         throw new UserInputError('Password must contain uppercase, lowercase, and numeric characters');
       }
     }

     static validatePhoneNumber(phone) {
       const phoneRegex = /^\+?[\d\s\-\(\)]{10,20}$/;
       if (!phoneRegex.test(phone)) {
         throw new UserInputError('Invalid phone number format');
       }
     }

     static validateRequired(value, fieldName) {
       if (!value || (typeof value === 'string' && !value.trim())) {
         throw new UserInputError(`${fieldName} is required`);
       }
     }

     static validateStringLength(value, fieldName, min = 0, max = 255) {
       if (typeof value !== 'string') {
         throw new UserInputError(`${fieldName} must be a string`);
       }
       
       if (value.length < min) {
         throw new UserInputError(`${fieldName} must be at least ${min} characters`);
       }
       
       if (value.length > max) {
         throw new UserInputError(`${fieldName} must not exceed ${max} characters`);
       }
     }

     static validateNumericRange(value, fieldName, min, max) {
       if (typeof value !== 'number' || isNaN(value)) {
         throw new UserInputError(`${fieldName} must be a valid number`);
       }
       
       if (min !== undefined && value < min) {
         throw new UserInputError(`${fieldName} must be at least ${min}`);
       }
       
       if (max !== undefined && value > max) {
         throw new UserInputError(`${fieldName} must not exceed ${max}`);
       }
     }
   }

   module.exports = {
     GraphQLErrorHandler,
     InputValidator
   };
   ```

8. **Performance Optimization**
   - Implement GraphQL performance optimizations:

   **Query Complexity and Depth Limiting:**
   ```javascript
   // utils/queryLimiting.js
   const depthLimit = require('graphql-depth-limit');
   const costAnalysis = require('graphql-query-complexity');

   class QueryLimiting {
     static createDepthLimit(maxDepth = 10) {
       return depthLimit(maxDepth, {
         ignoreIntrospection: true
       });
     }

     static createComplexityAnalysis(maxComplexity = 1000) {
       return costAnalysis({
         maximumComplexity: maxComplexity,
         introspection: true,
         scalarCost: 1,
         objectCost: 1,
         listFactor: 10,
         fieldExtensions: {
           complexity: (options) => {
             // Custom complexity calculation
             const { args, childComplexity } = options;
             
             // List fields have higher complexity
             if (args.first) {
               return childComplexity * Math.min(args.first, 100);
             }
             
             return childComplexity;
           }
         },
         createError: (max, actual) => {
           return new Error(`Query complexity ${actual} exceeds maximum allowed complexity ${max}`);
         }
       });
     }

     static createQueryTimeout(timeout = 30000) {
       return {
         willSendResponse(requestContext) {
           if (requestContext.request.query) {
             setTimeout(() => {
               if (!requestContext.response.http.body) {...

© BuildWithClaude Community · MIT · davepoon/buildwithclaude

Похожие слэш-команды

Все слэш-команды по теме «Бэкенд и API» →

Сначала — implement-graphql-api от других авторов.

implement-graphql-api davila7 Команда implement-graphql-api для Claude Code собирает GraphQL API: схему, резолверы, подписки и защиту от N+1. Выбор подхода: schema-first, code-first или federation. CX Codex +1 212установок graphql-schema-designer patricio0312rev Скилл graphql-schema-designer для Claude Code помогает спроектировать GraphQL API с типами, запросами, мутациями, подписками и резолверами. Включается по запросам о схеме, настройке GraphQL или Apollo Server. CX Codex +1 230установок graphql-expert personamanagmentlayer Скилл graphql-expert помогает проектировать GraphQL-схемы, писать резолверы и разбирать подписки. Пригодится при работе с Apollo Server, федерацией и проблемой N+1. CX Codex +1 169установок graphql-api-development manutej Скилл graphql-api-development для Claude Code, Codex, Cursor, Copilot и Gemini CLI по построению GraphQL API: схема, типы, резолверы, мутации, подписки, аутентификация и кэширование. CX Codex +1 449установок graphql-development Mindrally Скилл graphql-development для Claude Code задаёт агенту правила для GraphQL: схема, типизированные клиенты, интеграция с React и Next.js. Направляет написание резолверов и запросов. CX Codex +1 701установок apollo-graphql sanjeed5 Задаёт стандарты кода Apollo GraphQL на сервере и клиенте. Включается в проектах на JavaScript и JSX, где GraphQL-схему нужно держать строгой и документированной. CX Codex +1 ★ 3 589звёзд репо graphql-schema apollographql Скилл graphql-schema обучает проектированию схем GraphQL SDL по практикам Apollo. Помогает при создании schema.graphql, добавлении мутаций или настройке пагинации. CX Codex +1 4 500установок

Из того же набора235

Весь набор →
gsd-plan-checker Субагент gsd-plan-checker для Claude Code проверяет, ведут ли планы фазы к её цели, до начала работы. Ищет пропущенные требования и проблемы в задачах. CX Codex ★ 3 785звёзд репо gsd-doc-writer Субагент gsd-doc-writer, который пишет и обновляет документацию проекта. Создаёт README, гайды, API-справки и другие файлы, следуя структуре проекта и исправляя ошибки по проверкам. CX Codex ★ 3 785звёзд репо design-rest-api Команда design-rest-api задаёт правила проектирования RESTful API на Express.js с версионированием маршрутов, валидацией через Joi и выносом логики в контроллеры. CX Codex +1 ★ 3 785звёзд репо create-database-migrations Команда create-database-migrations для Claude Code помогает создавать и вести миграции базы данных. Она включается при запросе на изменение схемы и планирование отката. CX Codex +1 ★ 3 785звёзд репо gsd-debugger Субагент gsd-debugger ищет первопричину багов через проверяемые гипотезы, ведёт журнал отладки и запрашивает подтверждения на контрольных точках. CX Codex ★ 3 785звёзд репо gsd-planner Субагент gsd-planner разбивает фазу разработки на исполнимые планы, учитывает зависимости и проверяет задачи от цели назад. Запускается через /gsd:plan-phase. CX Codex ★ 3 785звёзд репо production-fast-api-template Скилл production-fast-api-template для Claude Code задаёт правила и структуру единого production-ready бэкенда на FastAPI с RAG и агентским ИИ на AWS ECS Fargate. CX Codex +1 ★ 3 785звёзд репо fix Скилл fix собирает данные об уязвимости по её идентификатору и предлагает конкретные шаги обновления зависимостей для репозитория. CX Codex +1 ★ 3 785звёзд репо

Спонсоры проекта

Компании, которые помогают держать аналитику открытой