implement-graphql-api · davepoon — команда для Claude Code
Команда implement-graphql-api проводит агента по шагам сборки GraphQL API: сервер, схема, типы, курсорная пагинация и корневые Query с Mutation.
MIT ★ 3 785 обновлён 2026-10-25
/plugin marketplace add davepoon/buildwithclaude
/plugin install all-commands@buildwithclaudeЧто делает 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@buildwithclaude2Вручную: положить файлы
.claude/commands/implement-graphql-api.mdВызов — /implement-graphql-api. Для всех проектов — ~/.claude/commands/
Вручную: положить файлы
~/.codex/prompts/implement-graphql-api.mdВызов — /prompts:implement-graphql-api. В Codex этот формат помечен устаревшим, замена — скиллы
Вручную: положить файлы
.github/prompts/implement-graphql-api.prompt.mdВручную: положить файлы
.gemini/commands/implement-graphql-api.tomlGemini хранит команды в TOML: текст запроса — в поле prompt
Вопросы об 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 от других авторов.