CRUD API на C# и GraphQL

public class Book
{
    public string Id { get; set; }
    public string Title { get; set; }
    public Author Author { get; set; }
    public int? PublicationYear { get; set; }
}

public class Query
{
    public Book GetBook(string id, [Service] IBookRepository repository)
    {
        return repository.GetBookById(id);
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services
        .AddGraphQLServer()
        .AddQueryType<Query>()
        .AddMutationType<Mutation>();
}
 
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapGraphQL();
    });
}

public class AuthorType : ObjectType<Author>
{
    protected override void Configure(IObjectTypeDescriptor<Author> descriptor)
    {
        descriptor.Field(a => a.Books)
            .ResolveWith<Resolvers>(r => r.GetBooks(default!, default!))
            .UseDbContext<AppDbContext>();
    }
 
    private class Resolvers
    {
        public IEnumerable<Book> GetBooks(Author author, [ScopedService] AppDbContext context)
        {
            return context.Books.Where(b => b.AuthorId == author.Id);
        }
    }
}

public class RequireAdminDirectiveType : DirectiveType
{
    protected override void Configure(IDirectiveTypeDescriptor descriptor)
    {
        descriptor.Name("requireAdmin");
        descriptor.Location(DirectiveLocation.Field);
        descriptor.Use(next => context =>
        {
            // Проверка прав администратора
            if (!context.User.IsInRole("Admin"))
            {
                throw new UnauthorizedAccessException("Доступ запрещен");
            }
            return next(context);
        });
    }
}

services
    .AddGraphQLServer()
    .AddDirectiveType<RequireAdminDirectiveType>()
    .AddQueryType<Query>();

public interface INamed
{
    string Name { get; }
}
 
public class Book : INamed
{
    public string Name { get; set; }
    // Другие поля
}
 
public class SearchResultType : UnionType
{
    protected override void Configure(IUnionTypeDescriptor descriptor)
    {
        descriptor.Name("SearchResult");
        descriptor.Type<BookType>();
        descriptor.Type<AuthorType>();
    }
}

services.AddGraphQLServer()
    .AddQueryType<Query>()
    .ModifyOptions(options =>
    {
        options.EnableSchemaRequests = true; // Включает запросы схемы через GET
        options.EnableIntrospection = true;  // Включает интроспекцию
    });

public class UppercaseDirectiveType : DirectiveType
{
    protected override void Configure(IDirectiveTypeDescriptor descriptor)
    {
        descriptor.Name("uppercase");
        descriptor.Location(DirectiveLocation.Field);
        descriptor.Use(next => context =>
        {
            var result = next(context);
            if (result is string value)
            {
                return value.ToUpper();
            }
            return result;
        });
    }
}

services.AddGraphQLServer()
    .AddDirectiveType<UppercaseDirectiveType>()

public class BookType : ObjectType<Book>
{
    protected override void Configure(IObjectTypeDescriptor<Book> descriptor)
    {
        descriptor.Field(b => b.OldField)
            .Deprecated("Используйте NewField вместо этого");
    }
}

// Book.cs
public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string ISBN { get; set; }
    public DateTime PublicationDate { get; set; }
    public int AuthorId { get; set; }
    
    public Author Author { get; set; }
}
 
// Author.cs
public class Author
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Biography { get; set; }
    
    public ICollection<Book> Books { get; set; } = new List<Book>();
}

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
    {
    }
 
    public DbSet<Book> Books { get; set; }
    public DbSet<Author> Authors { get; set; }
 
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Настраиваем связи между сущностями
        modelBuilder.Entity<Book>()
            .HasOne(b => b.Author)
            .WithMany(a => a.Books)
            .HasForeignKey(b => b.AuthorId);
            
        // Добавляем пример данных для тестирования
        modelBuilder.Entity<Author>().HasData(
            new Author { Id = 1, Name = "Джордж Оруэлл", Biography = "Британский писатель и журналист" },
            new Author { Id = 2, Name = "Федор Достоевский", Biography = "Русский писатель, мыслитель" }
        );
 
        modelBuilder.Entity<Book>().HasData(
            new Book { Id = 1, Title = "1984", ISBN = "978-5-17-086661-1", AuthorId = 1, PublicationDate = new DateTime(1949, 6, 8) },
            new Book { Id = 2, Title = "Скотный двор", ISBN = "978-5-17-086662-8", AuthorId = 1, PublicationDate = new DateTime(1945, 8, 17) },
            new Book { Id = 3, Title = "Преступление и наказание", ISBN = "978-5-17-086663-5", AuthorId = 2, PublicationDate = new DateTime(1866, 1, 1) }
        );
    }
}

// Регистрация DbContext
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
 
// Регистрация GraphQL
builder.Services
    .AddGraphQLServer()
    .AddQueryType<Query>()
    .AddMutationType<Mutation>()
    .AddType<BookType>()
    .AddType<AuthorType>()
    .RegisterDbContext<AppDbContext>();

// GraphQL/Types/BookType.cs
public class BookType : ObjectType<Book>
{
    protected override void Configure(IObjectTypeDescriptor<Book> descriptor)
    {
        descriptor.Description("Представляет книгу в системе");
        
        descriptor.Field(b => b.Id).Description("Уникальный идентификатор книги");
        descriptor.Field(b => b.Title).Description("Название книги");
        descriptor.Field(b => b.ISBN).Description("Международный стандартный книжный номер");
        descriptor.Field(b => b.PublicationDate).Description("Дата публикации");
        
        descriptor.Field(b => b.Author)
            .ResolveWith<Resolvers>(r => r.GetAuthor(default!, default!))
            .UseDbContext<AppDbContext>()
            .Description("Автор книги");
    }
    
    private class Resolvers
    {
        public Author GetAuthor(Book book, [ScopedService] AppDbContext context)
        {
            return context.Authors.FirstOrDefault(a => a.Id == book.AuthorId);
        }
    }
}
 
// GraphQL/Types/AuthorType.cs
public class AuthorType : ObjectType<Author>
{
    protected override void Configure(IObjectTypeDescriptor<Author> descriptor)
    {
        descriptor.Description("Представляет автора книг");
        
        descriptor.Field(a => a.Id).Description("Уникальный идентификатор автора");
        descriptor.Field(a => a.Name).Description("Имя автора");
        descriptor.Field(a => a.Biography).Description("Биография автора");
        
        descriptor.Field(a => a.Books)
            .ResolveWith<Resolvers>(r => r.GetBooks(default!, default!))
            .UseDbContext<AppDbContext>()
            .Description("Книги, написанные автором");
    }
    
    private class Resolvers
    {
        public IEnumerable<Book> GetBooks(Author author, [ScopedService] AppDbContext context)
        {
            return context.Books.Where(b => b.AuthorId == author.Id);
        }
    }
}

// GraphQL/Query.cs
public class Query
{
    [UseDbContext(typeof(AppDbContext))]
    [UseProjection]
    [UseFiltering]
    [UseSorting]
    public IQueryable<Book> GetBooks([ScopedService] AppDbContext context)
    {
        return context.Books;
    }
    
    [UseDbContext(typeof(AppDbContext))]
    public async Task<Book> GetBookAsync([ScopedService] AppDbContext context, int id)
    {
        return await context.Books.FindAsync(id);
    }
    
    [UseDbContext(typeof(AppDbContext))]
    [UseProjection]
    [UseFiltering]
    [UseSorting]
    public IQueryable<Author> GetAuthors([ScopedService] AppDbContext context)
    {
        return context.Authors;
    }
    
    [UseDbContext(typeof(AppDbContext))]
    public async Task<Author> GetAuthorAsync([ScopedService] AppDbContext context, int id)
    {
        return await context.Authors.FindAsync(id);
    }
}

builder.Services
    .AddGraphQLServer()
    .AddQueryType<Query>()
    .AddMutationType<Mutation>()
    .AddProjections()
    .AddFiltering()
    .AddSorting();

// GraphQL/Mutation.cs
public class Mutation
{
    // Создание новой книги
    [UseDbContext(typeof(AppDbContext))]
    public async Task<Book> AddBookAsync(
        [ScopedService] AppDbContext context,
        AddBookInput input)
    {
        var book = new Book
        {
            Title = input.Title,
            ISBN = input.ISBN,
            PublicationDate = input.PublicationDate,
            AuthorId = input.AuthorId
        };
 
        context.Books.Add(book);
        await context.SaveChangesAsync();
 
        return book;
    }
 
    // Обновление существующей книги
    [UseDbContext(typeof(AppDbContext))]
    public async Task<Book> UpdateBookAsync(
        [ScopedService] AppDbContext context,
        UpdateBookInput input)
    {
        var book = await context.Books.FindAsync(input.Id);
        
        if (book == null)
            throw new GraphQLException($"Книга с ID {input.Id} не найдена");
 
        book.Title = input.Title ?? book.Title;
        book.ISBN = input.ISBN ?? book.ISBN;
        
        if (input.PublicationDate.HasValue)
            book.PublicationDate = input.PublicationDate.Value;
            
        if (input.AuthorId.HasValue)
            book.AuthorId = input.AuthorId.Value;
 
        await context.SaveChangesAsync();
 
        return book;
    }
 
    // Удаление книги
    [UseDbContext(typeof(AppDbContext))]
    public async Task<bool> DeleteBookAsync(
        [ScopedService] AppDbContext context,
        int id)
    {
        var book = await context.Books.FindAsync(id);
        
        if (book == null)
            return false;
 
        context.Books.Remove(book);
        await context.SaveChangesAsync();
 
        return true;
    }
 
    // Аналогичные методы для авторов
    [UseDbContext(typeof(AppDbContext))]
    public async Task<Author> AddAuthorAsync(
        [ScopedService] AppDbContext context,
        AddAuthorInput input)
    {
        var author = new Author
        {
            Name = input.Name,
            Biography = input.Biography
        };
 
        context.Authors.Add(author);
        await context.SaveChangesAsync();
 
        return author;
    }
 
    // Другие методы для авторов...
}

// GraphQL/Types/BookInputs.cs
public record AddBookInput(
    string Title,
    string ISBN,
    DateTime PublicationDate,
    int AuthorId);
 
public record UpdateBookInput(
    int Id,
    string? Title = null,
    string? ISBN = null,
    DateTime? PublicationDate = null,
    int? AuthorId = null);
 
// GraphQL/Types/AuthorInputs.cs
public record AddAuthorInput(
    string Name,
    string? Biography = null);
 
public record UpdateAuthorInput(
    int Id,
    string? Name = null,
    string? Biography = null);

public class CustomErrorFilter : IErrorFilter
{
    public IError OnError(IError error)
    {
        if (error.Exception is DbUpdateException)
        {
            return error.WithMessage("Ошибка при сохранении в базу данных");
        }
        
        return error;
    }
}
 
// Регистрация в Program.cs
builder.Services
    .AddGraphQLServer()
    .AddErrorFilter<CustomErrorFilter>();

// Установите пакет
// dotnet add package HotChocolate.FluentValidation
 
public class AddBookInputValidator : AbstractValidator<AddBookInput>
{
    public AddBookInputValidator()
    {
        RuleFor(x => x.Title).NotEmpty().MaximumLength(200);
        RuleFor(x => x.ISBN).Matches(@"^\d{3}-\d{3}-\d{3}$").WithMessage("ISBN должен иметь формат XXX-XXX-XXX");
        RuleFor(x => x.PublicationDate).LessThanOrEqualTo(DateTime.Today);
    }
}
 
// Регистрация в Program.cs
builder.Services
    .AddGraphQLServer()
    .AddFluentValidation();

[UseDbContext(typeof(AppDbContext))]
public IQueryable<Book> GetBooks([ScopedService] AppDbContext context)
{
    return context.Books;
}

[UseDbContext(typeof(AppDbContext))]
public async Task<Book> AddBookWithAuthorUpdateAsync(
    [ScopedService] AppDbContext context,
    AddBookWithStatsInput input)
{
    // Важно: начинаем транзакцию
    using var transaction = await context.Database.BeginTransactionAsync();
    
    try
    {
        var book = new Book
        {
            Title = input.Title,
            ISBN = input.ISBN,
            PublicationDate = input.PublicationDate,
            AuthorId = input.AuthorId
        };
 
        context.Books.Add(book);
        
        // Обновляем статистику автора
        var author = await context.Authors.FindAsync(input.AuthorId);
        if (author == null)
            throw new GraphQLException($"Автор с ID {input.AuthorId} не найден");
            
        author.BookCount = await context.Books.CountAsync(b => b.AuthorId == input.AuthorId) + 1;
        author.LastBookPublished = input.PublicationDate;
        
        await context.SaveChangesAsync();
        
        // Если всё прошло успешно — коммитим транзакцию
        await transaction.CommitAsync();
        
        return book;
    }
    catch
    {
        // При любой ошибке — откатываем изменения
        await transaction.RollbackAsync();
        throw;
    }
}

[UseDbContext(typeof(AppDbContext))]
public IQueryable<Book> GetBooks([ScopedService] AppDbContext context)
{
    return context.Books.Include(b => b.Author);
}

public class AuthorDataLoader : BatchDataLoader<int, Author>
{
    private readonly IDbContextFactory<AppDbContext> _contextFactory;
 
    public AuthorDataLoader(
        IDbContextFactory<AppDbContext> contextFactory,
        IBatchScheduler batchScheduler)
        : base(batchScheduler)
    {
        _contextFactory = contextFactory;
    }
 
    protected override async Task<IReadOnlyDictionary<int, Author>> LoadBatchAsync(
        IReadOnlyList<int> keys,
        CancellationToken cancellationToken)
    {
        await using var context = await _contextFactory.CreateDbContextAsync(cancellationToken);
        
        return await context.Authors
            .Where(a => keys.Contains(a.Id))
            .ToDictionaryAsync(a => a.Id, cancellationToken);
    }
}

public class BookType : ObjectType<Book>
{
    protected override void Configure(IObjectTypeDescriptor<Book> descriptor)
    {
        descriptor.Field(b => b.Author)
            .ResolveWith<Resolvers>(r => r.GetAuthor(default!, default!));
    }
    
    private class Resolvers
    {
        public async Task<Author> GetAuthor(
            Book book,
            AuthorDataLoader authorLoader)
        {
            return await authorLoader.LoadAsync(book.AuthorId);
        }
    }
}

public record CreateBookWithAuthorInput(
    string Title,
    string ISBN,
    DateTime PublicationDate,
    AuthorInput Author);
 
public record AuthorInput(
    int? ExistingAuthorId,
    string? NewAuthorName,
    string? NewAuthorBiography);
 
public class CreateBookWithAuthorInputValidator : AbstractValidator<CreateBookWithAuthorInput>
{
    public CreateBookWithAuthorInputValidator()
    {
        RuleFor(x => x.Title).NotEmpty().MaximumLength(200);
        RuleFor(x => x.ISBN).NotEmpty().Matches(@"^[\d-]+$");
        
        RuleFor(x => x.Author.ExistingAuthorId)
            .NotNull()
            .When(x => string.IsNullOrEmpty(x.Author.NewAuthorName))
            .WithMessage("Необходимо указать либо ID существующего автора, либо информацию о новом авторе");
            
        RuleFor(x => x.Author.NewAuthorName)
            .NotEmpty()
            .When(x => x.Author.ExistingAuthorId == null)
            .WithMessage("Имя автора обязательно для нового автора");
    }
}

[UseDbContext(typeof(AppDbContext))]
public async Task<Book> CreateBookWithAuthorAsync(
    [ScopedService] AppDbContext context,
    CreateBookWithAuthorInput input)
{
    using var transaction = await context.Database.BeginTransactionAsync();
    
    try
    {
        int authorId;
        
        // Определяем ID автора (существующего или нового)
        if (input.Author.ExistingAuthorId.HasValue)
        {
            // Проверяем существование автора
            var author = await context.Authors.FindAsync(input.Author.ExistingAuthorId.Value);
            if (author == null)
                throw new GraphQLException($"Автор с ID {input.Author.ExistingAuthorId.Value} не найден");
                
            authorId = input.Author.ExistingAuthorId.Value;
        }
        else
        {
            // Создаём нового автора
            var newAuthor = new Author
            {
                Name = input.Author.NewAuthorName!,
                Biography = input.Author.NewAuthorBiography
            };
            
            context.Authors.Add(newAuthor);
            await context.SaveChangesAsync();
            
            authorId = newAuthor.Id;
        }
        
        // Создаём книгу
        var book = new Book
        {
            Title = input.Title,
            ISBN = input.ISBN,
            PublicationDate = input.PublicationDate,
            AuthorId = authorId
        };
        
        context.Books.Add(book);
        await context.SaveChangesAsync();
        
        await transaction.CommitAsync();
        
        return book;
    }
    catch
    {
        await transaction.RollbackAsync();
        throw;
    }
}

// Регистрация сервисов аутентификации в Program.cs
builder.Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuer = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
        ValidIssuer = builder.Configuration["Jwt:Issuer"],
        ValidAudience = builder.Configuration["Jwt:Audience"],
        IssuerSigningKey = new SymmetricSecurityKey(
            Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]))
    };
});
 
// Не забываем включить middleware аутентификации и авторизации
app.UseAuthentication();
app.UseAuthorization();

[Authorize]
public class Mutation
{
    // Только авторизованные пользователи могут выполнять мутации
}
 
public class Query
{
    [Authorize]
    public Book GetBookInternal(int id, [ScopedService] AppDbContext context)
    {
        // Только авторизованные пользователи могут получить эту книгу
    }
    
    [Authorize(Roles = "Admin")]
    public async Task<bool> DeleteBook(int id, [ScopedService] AppDbContext context)
    {
        // Только администраторы могут удалять книги
    }
}

public class BookType : ObjectType<Book>
{
    protected override void Configure(IObjectTypeDescriptor<Book> descriptor)
    {
        descriptor.Field(b => b.ISBN)
            .Authorize(new[] { "Admin", "Editor" })
            .Description("ISBN книги (доступно только админам и редакторам)");
            
        descriptor.Field(b => b.InternalNotes)
            .Authorize("Admin")
            .Description("Внутренние заметки (только для админов)");
    }
}

// Настройка политики в Program.cs
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("BookAuthor", policy =>
        policy.RequireAssertion(context =>
        {
            // Здесь будет логика проверки, является ли текущий пользователь автором книги
            return true; // Упрощено для примера
        }));
});
 
// Применение политики в мутации
[Authorize("BookAuthor")]
public async Task<Book> UpdateBook(int id, UpdateBookInput input, [ScopedService] AppDbContext context)
{
    // Реализация обновления книги
}

public class RequireAuthDirectiveType : DirectiveType
{
    protected override void Configure(IDirectiveTypeDescriptor descriptor)
    {
        descriptor.Name("requireAuth");
        descriptor.Location(DirectiveLocation.Field);
        descriptor.Use(next => context =>
        {
            if (!context.User.Identity.IsAuthenticated)
            {
                throw new UnauthorizedException("Требуется авторизация");
            }
            return next(context);
        });
    }
}
 
// Регистрация директивы
builder.Services
    .AddGraphQLServer()
    .AddDirectiveType<RequireAuthDirectiveType>();

public class Query
{
    [UseDbContext(typeof(AppDbContext))]
    [UsePaging]  // Вот она, магия пагинации!
    public IQueryable<Book> GetBooks([ScopedService] AppDbContext context)
    {
        return context.Books;
    }
}

[UsePaging(
    MaxPageSize = 50,          // Максимальное количество элементов на странице
    DefaultPageSize = 10,       // Размер страницы по умолчанию
    IncludeTotalCount = true    // Включать общее количество элементов
)]
public IQueryable<Book> GetBooks([ScopedService] AppDbContext context)
{
    return context.Books;
}

[Authorize]
[UsePaging]
[UseFiltering]
public IQueryable<Book> GetAccessibleBooks(
    [ScopedService] AppDbContext context,
    [Service] IUserAccessService accessService)
{
    var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
    var accessibleBookIds = accessService.GetAccessibleBookIds(userId);
    
    return context.Books.Where(b => accessibleBookIds.Contains(b.Id));
}

public class BookResolverTests
{
  [Fact]
  public async Task GetBook_ExistingId_ReturnsBook()
  {
      // Arrange
      var dbContextMock = new Mock<AppDbContext>();
      var bookId = 1;
      var expectedBook = new Book { Id = bookId, Title = "Тестовая книга" };
      
      dbContextMock.Setup(db => db.Books.FindAsync(bookId))
          .ReturnsAsync(expectedBook);
      
      var query = new Query();
      
      // Act
      var result = await query.GetBookAsync(dbContextMock.Object, bookId);
      
      // Assert
      Assert.Equal(expectedBook, result);
  }
}

public class BookQueryIntegrationTests : IClassFixture<TestServerFixture>
{
  private readonly TestServerFixture _fixture;
  
  public BookQueryIntegrationTests(TestServerFixture fixture)
  {
      _fixture = fixture;
  }
  
  [Fact]
  public async Task GetBook_ExistingId_ReturnsBook()
  {
      // Arrange
      var query = @"
          query {
              book(id: 1) {
                  id
                  title
              }
          }";
      
      // Act
      var result = await _fixture.ExecuteRequestAsync(query);
      
      // Assert
      result.MatchSnapshot(); // Сравнение с сохранённым эталонным ответом
  }
}

public class TestServerFixture : IDisposable
{
  private readonly TestServer _server;
  private readonly HttpClient _client;
  
  public TestServerFixture()
  {
      var hostBuilder = new WebHostBuilder()
          .ConfigureServices(services =>
          {
              // Настраиваем сервисы, используя тестовую БД
              services.AddDbContext<AppDbContext>(options =>
                  options.UseInMemoryDatabase("TestDb"));
                  
              services.AddGraphQLServer()
                  .AddQueryType<Query>()
                  .AddMutationType<Mutation>();
                  
              // Добавляем тестовые данные
              using var scope = services.BuildServiceProvider().CreateScope();
              var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
              SeedTestData(context);
          })
          .Configure(app =>
          {
              app.UseRouting();
              app.UseEndpoints(endpoints => endpoints.MapGraphQL());
          });
          
      _server = new TestServer(hostBuilder);
      _client = _server.CreateClient();
  }
  
  private void SeedTestData(AppDbContext context)
  {
      // Заполняем базу тестовыми данными
      context.Authors.Add(new Author { Id = 1, Name = "Тестовый Автор" });
      context.Books.Add(new Book { Id = 1, Title = "Тестовая книга", AuthorId = 1 });
      context.SaveChanges();
  }
  
  public async Task<IExecutionResult> ExecuteRequestAsync(string query)
  {
      var request = new HttpRequestMessage(HttpMethod.Post, "/graphql")
      {
          Content = new StringContent(
              JsonSerializer.Serialize(new { query }),
              Encoding.UTF8,
              "application/json")
      };
      
      var response = await _client.SendAsync(request);
      var content = await response.Content.ReadAsStringAsync();
      
      return QueryRequestBuilder.New()
          .SetQuery(query)
          .Create()
          .Execute(
              await _server.Services.GetRequiredService<ISchema>().CompileAsync());
  }
  
  public void Dispose()
  {
      _client.Dispose();
      _server.Dispose();
  }
}

services.AddGraphQLServer()
  .AddQueryType<Query>()
  .SetParsedDocumentCachingOptions(
      new ParseDocumentCachingOptions
      {
          MaxDocumentSize = 1024 * 20, // Макс. размер запроса - 20KB
      })
  .AddMaxExecutionDepthRule(10)  // Максимальная глубина запроса - 10 уровней
  .AddComplexityRule(200);       // Максимальная расчетная сложность - 200 единиц

public class BooksDataLoader : GroupedDataLoader<int, Book>
{
  private readonly IDbContextFactory<AppDbContext> _contextFactory;
  
  public BooksDataLoader(
      IDbContextFactory<AppDbContext> contextFactory,
      DataLoaderOptions options) : base(options)
  {
      _contextFactory = contextFactory;
  }
  
  protected override async Task<ILookup<int, Book>> LoadGroupedBatchAsync(
      IReadOnlyList<int> authorIds,
      CancellationToken cancellationToken)
  {
      await using var context = await _contextFactory.CreateDbContextAsync(cancellationToken);
      
      var books = await context.Books
          .Where(b => authorIds.Contains(b.AuthorId))
          .ToListAsync(cancellationToken);
          
      return books.ToLookup(b => b.AuthorId);
  }
}

public class AuthorType : ObjectType<Author>
{
  protected override void Configure(IObjectTypeDescriptor<Author> descriptor)
  {
      descriptor.Field(a => a.Books)
          .ResolveWith<Resolvers>(r => r.GetBooks(default!, default!));
  }
  
  private class Resolvers
  {
      public async Task<IEnumerable<Book>> GetBooks(
          Author author,
          BooksDataLoader dataLoader)
      {
          return await dataLoader.LoadAsync(author.Id);
      }
  }
}

services.AddOpenTelemetryTracing(builder => builder
  .AddHotChocolateInstrumentation()
  .AddZipkinExporter());

services.AddDbContext<AppDbContext>(options =>
  options.UseSqlServer(connectionString)
         .EnableSensitiveDataLogging()
         .LogTo(Console.WriteLine, LogLevel.Information));

[UseProjection]
public IQueryable<Book> GetBooks([ScopedService] AppDbContext context)
{
  return context.Books;
}

services.AddGraphQLServer()
  .AddQueryType<Query>()
  .AddCaching(options =>
  {
      options.EnableQueryCache = true;
      options.MaxQueryCacheSize = 1000;
  });

[NodeResolver]
[UseCaching(maxAge: 60)] // Кэширование на 60 секунд
public async Task<Book> GetBookById(int id, BookByIdDataLoader dataLoader)
{
    return await dataLoader.LoadAsync(id);
}

app.UseResponseCompression();
 
services.AddResponseCompression(options =>
{
    options.EnableForHttps = true;
    options.Providers.Add<BrotliCompressionProvider>();
    options.Providers.Add<GzipCompressionProvider>();
});

services.AddGraphQLServer()
  .AddApolloTracing(TracingPreference.Always);

modelBuilder.Entity<Book>()
    .HasIndex(b => b.Title);
    
modelBuilder.Entity<Book>()
    .HasIndex(b => b.AuthorId);

// Небезопасно! Никогда так не делайте:
var query = $"query {{ book(id: \"{userInput}\") {{ title }} }}";
var result = await executor.ExecuteAsync(query);
 
// Правильный способ - использование переменных:
var query = "query($id: ID!) { book(id: $id) { title } }";
var variables = new { id = userInput };
var result = await executor.ExecuteAsync(query, variables);

public class SecureErrorFilter : IErrorFilter
{
    public IError OnError(IError error)
    {
        if (error.Exception is AccessViolationException)
            return error.WithMessage("Доступ запрещён");
            
        if (error.Exception is Exception ex)
        {
            // Логируем исключение для отладки
            _logger.LogError(ex, "GraphQL error");
            // Возвращаем клиенту общее сообщение
            return error.WithMessage("Внутренняя ошибка сервера");
        }
        
        return error;
    }
}

services
    .AddGraphQLServer()
    .AddQueryType<Query>()
    .AddRemoteSchema("products", ignoreRootTypes: true)
    .AddRemoteSchema("customers", ignoreRootTypes: true)
    .AddTypeExtensionsFromFile("./Stitching.graphql");

services
    .AddGraphQLServer()
    .AddQueryType<Query>()
    .AddRedisQueryStorage(_ => ConnectionMultiplexer.Connect("localhost:6379"));

[UseCaching(cacheTags: new[] { "Book", "Author" })]
public Book GetBook(int id, [ScopedService] AppDbContext context)
{
    return context.Books.First(b => b.Id == id);
}

[UseInvalidateCacheTags(Tags = new[] { "Book" })]
public async Task<Book> AddBook(AddBookInput input, [ScopedService] AppDbContext context)
{
    // Реализация добавления книги
}

public class Subscription
{
    [Subscribe]
    public Book BookAdded([EventMessage] Book book) => book;
    
    [Subscribe(MessageType = typeof(string))]
    public Book BookTitleChanged([EventMessage] string title) => 
        new Book { Title = title };
}

public class Mutation
{
    public async Task<Book> AddBook(
        AddBookInput input,
        [ScopedService] AppDbContext context,
        [Service] ITopicEventSender eventSender)
    {
        var book = new Book
        {
            Title = input.Title,
            // ... другие поля
        };
        
        context.Books.Add(book);
        await context.SaveChangesAsync();
        
        // Отправляем событие в поток подписки
        await eventSender.SendAsync(nameof(Subscription.BookAdded), book);
        
        return book;
    }
}

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services
            .AddGraphQLServer()
            .AddQueryType(d => d.Name("Query"))
            .AddRemoteSchema("books", 
                ignoreRootTypes: true,
                includeTypeNames: true)
            .AddRemoteSchema("authors", 
                ignoreRootTypes: true,
                includeTypeNames: true)
            .AddTypeExtensionsFromFile("./stitching.graphql");
    }
}

public class BookAddedEventConsumer : BackgroundService
{
    private readonly ITopicEventSender _eventSender;
    private readonly IModel _channel;
 
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _channel.QueueDeclare("book_events", durable: true, exclusive: false);
        var consumer = new EventingBasicConsumer(_channel);
        
        consumer.Received += (model, ea) =>
        {
            var body = ea.Body.ToArray();
            var message = Encoding.UTF8.GetString(body);
            var book = JsonSerializer.Deserialize<Book>(message);
            
            // Отправляем событие в GraphQL-подписку
            _eventSender.SendAsync(nameof(Subscription.BookAdded), book);
        };
        
        _channel.BasicConsume(queue: "book_events", autoAck: true, consumer: consumer);
        
        // Ожидаем остановки службы
        await Task.Delay(-1, stoppingToken);
    }
}