أمان واجهات GraphQL

# استعلام عميق يستهلك موارد كثيرة
query {
  user {
    posts {
      comments {
        user {
          posts {
            comments {
              user { name }
            }
          }
        }
      }
    }
  }
}

const depthLimit = require('graphql-depth-limit');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [depthLimit(5)], // أقصى عمق 5 مستويات
});

const { createComplexityLimitRule } = require('graphql-validation-complexity');

const typeDefs = `
  type Query {
    users: [User] @complexity(value: 10)
    user(id: ID!): User @complexity(value: 2)
    searchUsers(query: String!): [User] @complexity(value: 5)
  }

  type User {
    id: ID
    name: String
    posts: [Post] @complexity(value: 3)
    friends: [User] @complexity(value: 8)
  }
`;

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [
    createComplexityLimitRule(100, {
      onCost: (cost) => console.log(`Query cost: ${cost}`),
    }),
  ],
});

query {
  user1: user(id: 1) { name }
  user2: user(id: 2) { name }
  user3: user(id: 3) { name }
  # ... مئات المستخدمين
}

const graphqlRateLimit = require('graphql-rate-limit');

const rateLimitDirective = graphqlRateLimit({
  identifyContext: (ctx) => ctx.user?.id || ctx.ip,
});

const typeDefs = `
  directive @rateLimit(
    max: Int,
    window: String
  ) on FIELD_DEFINITION

  type Query {
    users: [User] @rateLimit(max: 10, window: "1m")
    user(id: ID!): User @rateLimit(max: 100, window: "1m")
  }
`;

const { mapSchema, getDirectives, MapperKind } = require('@graphql-tools/utils');
const { defaultFieldResolver } = require('graphql');

const authDirectiveTransformer = (schema) =>
  mapSchema(schema, {
    [MapperKind.OBJECT_FIELD]: (fieldConfig) => {
      const directives = getDirectives(schema, fieldConfig);
      const authDirective = directives['auth'];

      if (authDirective) {
        const { role } = authDirective;
        const originalResolver = fieldConfig.resolve || defaultFieldResolver;

        fieldConfig.resolve = async (source, args, context, info) => {
          if (!context.user) {
            throw new AuthenticationError('يجب تسجيل الدخول أولاً');
          }

          if (role && context.user.role !== role && context.user.role !== 'admin') {
            throw new ForbiddenError('ليس لديك صلاحية');
          }

          return originalResolver(source, args, context, info);
        };
      }

      return fieldConfig;
    },
  });

const typeDefs = `
  directive @auth(role: String) on FIELD_DEFINITION

  type Query {
    users: [User] @auth(role: "admin")
    me: User @auth
  }
`;

const persistedQueries = {
  'sha256hash1': `
    query GetUser($id: ID!) {
      user(id: $id) { id name email }
    }
  `,
  'sha256hash2': `
    query GetPosts {
      posts { id title }
    }
  `,
};

const server = new ApolloServer({
  typeDefs,
  resolvers,
  persistedQueries: {
    ttl: 3600, // تخزين مؤقت للاستعلامات
  },
});

const server = new ApolloServer({
  typeDefs,
  resolvers,
  introspection: process.env.NODE_ENV !== 'production',
});

const rateLimiters = {
  Query: {
    users: { windowMs: 60000, max: 10 },
    search: { windowMs: 60000, max: 30 },
  },
  Mutation: {
    login: { windowMs: 60000, max: 5 },
    createPost: { windowMs: 60000, max: 20 },
  },
};

// مثال: تسجيل الاستعلامات البطيئة
server.requestDidStart((requestContext) => {
  const startTime = Date.now();

  return {
    willSendResponse() {
      const duration = Date.now() - startTime;
      if (duration > 1000) {
        console.warn('Slow query detected:', {
          query: requestContext.request.query,
          duration,
          operationName: requestContext.request.operationName,
        });
      }
    },
  };
});