From 6013405fd4b486e1acbe76e91737dcf52353425a Mon Sep 17 00:00:00 2001
From: Nikita Vasilev <nv3212@gmail.com>
Date: Sun, 21 Dec 2025 21:00:14 +0400
Subject: [PATCH 1/2] docs: update README.md

---
 CODE_OF_CONDUCT.md | 133 +++++++++
 CONTRIBUTING.md    | 651 +++++++++++++++++++++++++++++++++++++++++++++
 README.md          | 458 ++++++++++++++++++++++++++++---
 hooks/pre-commit   |  38 ---
 4 files changed, 1200 insertions(+), 80 deletions(-)
 create mode 100644 CODE_OF_CONDUCT.md
 create mode 100644 CONTRIBUTING.md
 delete mode 100755 hooks/pre-commit

diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..fa7ff7a
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,133 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+nv3212@gmail.com.
+
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..12c1b70
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,651 @@
+# Contributing to NetworkLayer
+
+First off, thank you for considering contributing to NetworkLayer! It's people like you that make NetworkLayer such a great tool for network communication.
+
+## Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [Getting Started](#getting-started)
+  - [Development Setup](#development-setup)
+  - [Project Structure](#project-structure)
+- [How Can I Contribute?](#how-can-i-contribute)
+  - [Reporting Bugs](#reporting-bugs)
+  - [Suggesting Features](#suggesting-features)
+  - [Improving Documentation](#improving-documentation)
+  - [Submitting Code](#submitting-code)
+- [Development Workflow](#development-workflow)
+  - [Branching Strategy](#branching-strategy)
+  - [Commit Guidelines](#commit-guidelines)
+  - [Pull Request Process](#pull-request-process)
+- [Coding Standards](#coding-standards)
+  - [Swift Style Guide](#swift-style-guide)
+  - [Code Quality](#code-quality)
+  - [Testing Requirements](#testing-requirements)
+- [Community](#community)
+
+## Code of Conduct
+
+This project and everyone participating in it is governed by our Code of Conduct. By participating, you are expected to uphold this code. Please report unacceptable behavior to nv3212@gmail.com.
+
+## Getting Started
+
+### Development Setup
+
+1. **Fork the repository**
+   ```bash
+   # Click the "Fork" button on GitHub
+   ```
+
+2. **Clone your fork**
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/network-layer.git
+   cd network-layer
+   ```
+
+3. **Set up the development environment**
+   ```bash
+   # Bootstrap the project
+   mise install
+   ```
+
+4. **Create a feature branch**
+   ```bash
+   git checkout -b feature/your-feature-name
+   ```
+
+5. **Open the project in Xcode**
+   ```bash
+   open Package.swift
+   ```
+
+## How Can I Contribute?
+
+### Reporting Bugs
+
+Before creating a bug report, please check the [existing issues](https://github.com/space-code/network-layer/issues) to avoid duplicates.
+
+When creating a bug report, include:
+
+- **Clear title** - Describe the issue concisely
+- **Reproduction steps** - Detailed steps to reproduce the bug
+- **Expected behavior** - What you expected to happen
+- **Actual behavior** - What actually happened
+- **Environment** - OS, Xcode version, Swift version
+- **Code samples** - Minimal reproducible example
+- **Error messages** - Complete error output if applicable
+
+**Example:**
+```markdown
+**Title:** RequestProcessor fails to refresh credentials on 401 response
+
+**Steps to reproduce:**
+1. Configure RequestProcessor with authentication interceptor
+2. Make request with requiresAuthentication = true
+3. Server returns 401
+4. Observe that refresh is not triggered
+
+**Expected:** Authentication interceptor should refresh credentials
+**Actual:** Request fails without refresh attempt
+
+**Environment:**
+- iOS 16.0
+- Xcode 14.3
+- Swift 5.7
+
+**Code:**
+\`\`\`swift
+let interceptor = MyAuthInterceptor()
+let configuration = Configuration(
+    sessionConfiguration: .default,
+    interceptor: interceptor
+)
+let processor = NetworkLayerAssembly().assemble(configuration: configuration)
+
+struct AuthRequest: IRequest {
+    var domainName: String { "https://api.example.com" }
+    var path: String { "secure/data" }
+    var httpMethod: HTTPMethod { .get }
+    var requiresAuthentication: Bool { true }
+}
+
+let response: Response<Data> = try await processor.send(AuthRequest())
+\`\`\`
+```
+
+### Suggesting Features
+
+We love feature suggestions! When proposing a new feature, include:
+
+- **Problem statement** - What problem does this solve?
+- **Proposed solution** - How should it work?
+- **Alternatives** - What alternatives did you consider?
+- **Use cases** - Real-world scenarios
+- **API design** - Example code showing usage
+- **Breaking changes** - Will this break existing code?
+
+**Example:**
+```markdown
+**Feature:** Add request/response interceptor chain
+
+**Problem:** Currently only one authentication interceptor is supported. Complex apps need multiple interceptors for logging, analytics, error handling, etc.
+
+**Solution:** Add interceptor chain that executes multiple interceptors in order.
+
+**API:**
+\`\`\`swift
+let configuration = Configuration(
+    sessionConfiguration: .default,
+    interceptors: [
+        LoggingInterceptor(),
+        AuthenticationInterceptor(),
+        AnalyticsInterceptor()
+    ]
+)
+\`\`\`
+
+**Use case:** Mobile app needs to:
+1. Log all requests/responses
+2. Add authentication headers
+3. Track API usage analytics
+4. Handle rate limiting
+```
+
+### Improving Documentation
+
+Documentation improvements are always welcome:
+
+- **Code comments** - Add/improve inline documentation
+- **DocC documentation** - Enhance documentation articles
+- **README** - Fix typos, add examples
+- **Guides** - Write tutorials or how-to guides
+- **API documentation** - Document public APIs
+- **Migration guides** - Help users upgrade versions
+
+### Submitting Code
+
+1. **Check existing work** - Look for related issues or PRs
+2. **Discuss major changes** - Open an issue for large features
+3. **Follow coding standards** - See [Coding Standards](#coding-standards)
+4. **Write tests** - All code changes require tests
+5. **Update documentation** - Keep docs in sync with code
+6. **Create a pull request** - Use clear description
+
+## Development Workflow
+
+### Branching Strategy
+
+We use a simplified branching model:
+
+- **`main`** - Main development branch (all PRs target this)
+- **`feature/*`** - New features
+- **`fix/*`** - Bug fixes
+- **`docs/*`** - Documentation updates
+- **`refactor/*`** - Code refactoring
+- **`test/*`** - Test improvements
+
+**Branch naming examples:**
+```bash
+feature/interceptor-chain
+fix/credential-refresh-timing
+docs/update-authentication-guide
+refactor/simplify-request-builder
+test/add-retry-integration-tests
+```
+
+### Commit Guidelines
+
+We use [Conventional Commits](https://www.conventionalcommits.org/) for clear, structured commit history.
+
+**Format:**
+```
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+```
+
+**Types:**
+- `feat` - New feature
+- `fix` - Bug fix
+- `docs` - Documentation changes
+- `style` - Code style (formatting, no logic changes)
+- `refactor` - Code refactoring
+- `test` - Adding or updating tests
+- `chore` - Maintenance tasks
+- `perf` - Performance improvements
+
+**Scopes:**
+- `core` - Core networking logic
+- `processor` - RequestProcessor
+- `builder` - RequestBuilder
+- `auth` - Authentication
+- `retry` - Retry logic
+- `config` - Configuration
+- `interfaces` - Protocol interfaces
+- `assembly` - Dependency injection
+
+**Examples:**
+```bash
+feat(auth): add interceptor chain support
+
+Implement support for multiple interceptors that execute in sequence.
+Each interceptor can modify requests and handle authentication challenges.
+
+Closes #78
+
+---
+
+fix(processor): correct credential refresh detection
+
+The refresh method was checking HTTP status codes incorrectly,
+causing valid 401 responses to be ignored. Now properly delegates
+to interceptor's isRequireRefresh method.
+
+Fixes #92
+
+---
+
+docs(readme): add GraphQL client example
+
+Add practical example showing how to use NetworkLayer with GraphQL APIs,
+including query variables and error handling.
+
+---
+
+test(retry): add integration tests for retry policies
+
+Add tests for:
+- Retry with constant strategy
+- Retry with exponential backoff
+- Retry with custom shouldRetry evaluation
+- Interaction between global and local retry evaluators
+```
+
+**Commit message rules:**
+- Use imperative mood ("add" not "added")
+- Don't capitalize first letter
+- No period at the end
+- Keep subject line under 72 characters
+- Separate subject from body with blank line
+- Reference issues in footer
+
+### Pull Request Process
+
+1. **Update your branch**
+   ```bash
+   git checkout main
+   git pull upstream main
+   git checkout feature/your-feature
+   git rebase main
+   ```
+
+2. **Run tests and checks**
+   ```bash
+   # Run all tests
+   swift test
+   
+   # Check test coverage
+   swift test --enable-code-coverage
+   
+   # Run specific test suite
+   swift test --filter NetworkLayerTests
+   ```
+
+3. **Push to your fork**
+   ```bash
+   git push origin feature/your-feature
+   ```
+
+4. **Create pull request**
+   - Target the `main` branch
+   - Provide clear description
+   - Link related issues
+   - Include examples if applicable
+   - Request review from maintainers
+
+5. **Review process**
+   - Address review comments
+   - Keep PR up to date with main
+   - Squash commits if requested
+   - Wait for CI to pass
+
+6. **After merge**
+   ```bash
+   # Clean up local branch
+   git checkout main
+   git pull upstream main
+   git branch -d feature/your-feature
+   
+   # Clean up remote branch
+   git push origin --delete feature/your-feature
+   ```
+
+## Coding Standards
+
+### Swift Style Guide
+
+We follow the [Swift API Design Guidelines](https://swift.org/documentation/api-design-guidelines/) and [Ray Wenderlich Swift Style Guide](https://github.com/raywenderlich/swift-style-guide).
+
+**Key points:**
+
+1. **Naming**
+   ```swift
+   // ✅ Good
+   func send<M: Decodable>(_ request: some IRequest) async throws -> Response<M>
+   let requestProcessor: IRequestProcessor
+   
+   // ❌ Bad
+   func doSend(_ req: Any) async throws -> Any
+   let proc: Any
+   ```
+
+2. **Protocols**
+   ```swift
+   // ✅ Good - Use "I" prefix for protocols
+   protocol IRequestProcessor {
+       func send<M: Decodable>(_ request: some IRequest) async throws -> Response<M>
+   }
+   
+   protocol IAuthenticationInterceptor {
+       func adapt(request: inout URLRequest, for session: URLSession) async throws
+   }
+   
+   // ❌ Bad
+   protocol RequestProcessor { }
+   protocol Authenticator { }
+   ```
+
+3. **Access Control**
+   ```swift
+   // ✅ Good - Explicit access control
+   public actor RequestProcessor {
+       private let configuration: Configuration
+       private let session: URLSession
+       private let requestBuilder: IRequestBuilder
+       
+       public func send<M: Decodable>(
+           _ request: some IRequest
+       ) async throws -> Response<M> {
+           // Implementation
+       }
+   }
+   ```
+
+4. **Documentation**
+   ```swift
+   /// An actor responsible for executing network requests in a thread-safe manner.
+   ///
+   /// `RequestProcessor` manages the entire lifecycle of a request, including construction,
+   /// authentication adaptation, execution, credential refreshing, and retry logic.
+   ///
+   /// - Note: All operations are performed within the actor's isolation domain,
+   ///   ensuring thread-safe access to internal state.
+   ///
+   /// - Example:
+   /// ```swift
+   /// let processor = NetworkLayerAssembly().assemble()
+   /// let response: Response<User> = try await processor.send(GetUserRequest())
+   /// print("Fetched user: \(response.value.name)")
+   /// ```
+   public actor RequestProcessor: IRequestProcessor {
+       // Implementation
+   }
+   ```
+
+5. **Actor Usage**
+   ```swift
+   // ✅ Good - Use actors for thread-safe state management
+   actor RequestProcessor {
+       private let configuration: Configuration
+       
+       func performRequest() async throws -> Response<Data> {
+           // Thread-safe access to configuration
+       }
+   }
+   
+   // ❌ Bad - Avoid @MainActor unless UI-related
+   @MainActor
+   class RequestProcessor { }
+   ```
+
+### Code Quality
+
+- **No force unwrapping** - Use optional binding or guards
+- **No force casting** - Use conditional casting
+- **No magic numbers** - Use named constants
+- **Single responsibility** - One class, one purpose
+- **DRY principle** - Don't repeat yourself
+- **SOLID principles** - Follow SOLID design
+- **Actor isolation** - Respect Swift concurrency boundaries
+
+**Example:**
+```swift
+// ✅ Good
+private enum NetworkConstants {
+    static let defaultTimeout: TimeInterval = 60
+    static let maxRetryAttempts = 3
+}
+
+guard let urlRequest = try requestBuilder.build(request, configure) else {
+    throw NetworkLayerError.badURL
+}
+
+// ❌ Bad
+let timeout = 60.0  // Magic number
+let request = try requestBuilder.build(request, configure)!  // Force unwrap
+```
+
+### Testing Requirements
+
+All code changes must include tests:
+
+1. **Unit tests** - Test individual components
+2. **Integration tests** - Test component interactions
+3. **Edge cases** - Test boundary conditions
+4. **Error handling** - Test failure scenarios
+5. **Concurrency tests** - Test actor isolation and async behavior
+6. **Mock tests** - Use Mocker for network mocking
+
+**Coverage requirements:**
+- New code: minimum 80% coverage
+- Modified code: maintain or improve existing coverage
+- Critical paths: 100% coverage
+
+**Test structure:**
+```swift
+import XCTest
+@testable import NetworkLayer
+import Mocker
+
+final class RequestProcessorTests: XCTestCase {
+    var sut: RequestProcessor!
+    var configuration: Configuration!
+    var mockSession: URLSession!
+    
+    override func setUp() {
+        super.setUp()
+        
+        let mockConfiguration = URLSessionConfiguration.default
+        mockConfiguration.protocolClasses = [MockingURLProtocol.self]
+        
+        configuration = Configuration(sessionConfiguration: mockConfiguration)
+        sut = NetworkLayerAssembly().assemble(configuration: configuration)
+    }
+    
+    override func tearDown() {
+        sut = nil
+        configuration = nil
+        mockSession = nil
+        super.tearDown()
+    }
+    
+    // MARK: - Success Tests
+    
+    func testSend_WithValidRequest_ReturnsDecodedResponse() async throws {
+        // Given
+        let expectedUser = User(id: "123", name: "John Doe")
+        let requestURL = URL(string: "https://api.example.com/users/123")!
+        
+        let mockedData = try JSONEncoder().encode(expectedUser)
+        let mock = Mock(url: requestURL, dataType: .json, statusCode: 200, data: [.get: mockedData])
+        mock.register()
+        
+        struct GetUserRequest: IRequest {
+            var domainName: String { "https://api.example.com" }
+            var path: String { "users/123" }
+            var httpMethod: HTTPMethod { .get }
+        }
+        
+        // When
+        let response: Response<User> = try await sut.send(GetUserRequest())
+        
+        // Then
+        XCTAssertEqual(response.value.id, expectedUser.id)
+        XCTAssertEqual(response.value.name, expectedUser.name)
+    }
+    
+    // MARK: - Failure Tests
+    
+    func testSend_WithNetworkError_ThrowsError() async {
+        // Given
+        let requestURL = URL(string: "https://api.example.com/users/123")!
+        let mock = Mock(url: requestURL, dataType: .json, statusCode: 500, data: [.get: Data()])
+        mock.register()
+        
+        struct GetUserRequest: IRequest {
+            var domainName: String { "https://api.example.com" }
+            var path: String { "users/123" }
+            var httpMethod: HTTPMethod { .get }
+        }
+        
+        // Then
+        await XCTAssertThrowsError(
+            try await sut.send(GetUserRequest()) as Response<User>
+        )
+    }
+    
+    // MARK: - Authentication Tests
+    
+    func testSend_WithAuthentication_AdaptsRequest() async throws {
+        // Given
+        let token = "test-token"
+        let interceptor = MockAuthInterceptor(token: token)
+        let config = Configuration(
+            sessionConfiguration: .default,
+            interceptor: interceptor
+        )
+        sut = NetworkLayerAssembly().assemble(configuration: config)
+        
+        struct AuthRequest: IRequest {
+            var domainName: String { "https://api.example.com" }
+            var path: String { "secure" }
+            var httpMethod: HTTPMethod { .get }
+            var requiresAuthentication: Bool { true }
+        }
+        
+        // When/Then
+        // Verify interceptor was called with correct parameters
+    }
+    
+    // MARK: - Retry Tests
+    
+    func testSend_WithRetryPolicy_RetriesOnFailure() async throws {
+        // Given
+        let retryService = RetryPolicyService(
+            strategy: .constant(retry: 2, duration: .milliseconds(100))
+        )
+        sut = NetworkLayerAssembly().assemble(
+            configuration: configuration,
+            retryPolicyService: retryService
+        )
+        
+        var attemptCount = 0
+        
+        // When/Then
+        // Verify retry behavior
+    }
+    
+    // MARK: - Concurrency Tests
+    
+    func testSend_WithConcurrentRequests_HandlesAllRequests() async throws {
+        // Given
+        let requestCount = 10
+        
+        // When
+        let responses = try await withThrowingTaskGroup(of: Response<User>.self) { group in
+            for i in 0..<requestCount {
+                group.addTask {
+                    try await self.sut.send(GetUserRequest(id: "\(i)"))
+                }
+            }
+            
+            var results: [Response<User>] = []
+            for try await response in group {
+                results.append(response)
+            }
+            return results
+        }
+        
+        // Then
+        XCTAssertEqual(responses.count, requestCount)
+    }
+}
+
+// MARK: - Test Helpers
+
+private struct User: Codable, Equatable {
+    let id: String
+    let name: String
+}
+
+private class MockAuthInterceptor: IAuthenticationInterceptor {
+    let token: String
+    
+    init(token: String) {
+        self.token = token
+    }
+    
+    func adapt(request: inout URLRequest, for session: URLSession) async throws {
+        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+    }
+    
+    func isRequireRefresh(_ request: URLRequest, response: HTTPURLResponse) -> Bool {
+        response.statusCode == 401
+    }
+    
+    func refresh(
+        _ request: URLRequest,
+        with response: HTTPURLResponse,
+        for session: URLSession
+    ) async throws {
+        // Mock refresh logic
+    }
+}
+```
+
+## Community
+
+- **Discussions** - Join [GitHub Discussions](https://github.com/space-code/network-layer/discussions)
+- **Issues** - Track [open issues](https://github.com/space-code/network-layer/issues)
+- **Pull Requests** - Review [open PRs](https://github.com/space-code/network-layer/pulls)
+
+## Recognition
+
+Contributors are recognized in:
+- GitHub contributors page
+- Release notes
+- Project README (for significant contributions)
+
+## Questions?
+
+- Check [existing issues](https://github.com/space-code/network-layer/issues)
+- Search [discussions](https://github.com/space-code/network-layer/discussions)
+- Ask in [Q&A discussions](https://github.com/space-code/network-layer/discussions/categories/q-a)
+- Email the maintainer: nv3212@gmail.com
+
+---
+
+Thank you for contributing to NetworkLayer! 🎉
+
+Your efforts help make network communication better for everyone.
\ No newline at end of file
diff --git a/README.md b/README.md
index ca6b8fa..2b7a8b5 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-![NetworkLayer: Network communication made easy](https://raw.githubusercontent.com/space-code/network-layer/dev/Resources/network-layer.png)
+![NetworkLayer: Network communication made easy](./Resources/network-layer.png)
 
 <h1 align="center" style="margin-top: 0px;">network-layer</h1>
 
@@ -8,92 +8,466 @@
 <a href="https://swiftpackageindex.com/space-code/network-layer"><img alt="Platform Compatibility" src="https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2Fspace-code%2Fnetwork-layer%2Fbadge%3Ftype%3Dplatforms"/></a> 
 <a href="https://github.com/space-code/network-layer"><img alt="CI" src="https://github.com/space-code/network-layer/actions/workflows/ci.yml/badge.svg?branch=main"></a>
 <a href="https://github.com/apple/swift-package-manager" alt="network-layer on Swift Package Manager" title="network-layer on Swift Package Manager"><img src="https://img.shields.io/badge/Swift%20Package%20Manager-compatible-brightgreen.svg" /></a>
-<a href="https://codecov.io/gh/space-code/network-layer" > <img src="https://codecov.io/gh/space-code/network-layer/graph/badge.svg?token=lWsPUf5nPL"/></a>
+<a href="https://codecov.io/gh/space-code/network-layer"><img src="https://codecov.io/gh/space-code/network-layer/graph/badge.svg?token=lWsPUf5nPL"/></a>
 </p>
 
 ## Description
-`network-layer` is a library for network communication.
+NetworkLayer is a modern, type-safe Swift framework for elegant network communication. Built with Swift's async/await concurrency model and actor-based architecture, it provides a robust foundation for making HTTP requests with features like authentication handling, retry policies, and request processing.
+
+## Features
+
+✨ **Type-Safe Requests** - Protocol-based request modeling with compile-time safety  
+⚡ **Async/Await Native** - Built for modern Swift concurrency with actor-based thread safety  
+🔐 **Authentication Support** - Built-in authentication interceptor with credential refresh  
+🔄 **Retry Policies** - Powered by [Typhoon](https://github.com/space-code/typhoon) for robust failure handling  
+🎯 **Flexible Configuration** - Customizable session configuration, decoders, and delegates  
+📱 **Cross-Platform** - Works on iOS, macOS, tvOS, watchOS, and visionOS  
+⚡ **Lightweight** - Minimal footprint with focused dependencies  
+🧪 **Well Tested** - Comprehensive test coverage
+
+## Table of Contents
 
-- [Usage](#usage)
-- [Documentation](#documentation)
 - [Requirements](#requirements)
 - [Installation](#installation)
+- [Architecture](#architecture)
+- [Quick Start](#quick-start)
+- [Usage](#usage)
+  - [Basic Requests](#basic-requests)
+  - [Authentication](#authentication)
+  - [Retry Policies](#retry-policies)
+  - [Custom Configuration](#custom-configuration)
+  - [Request Validation](#request-validation)
+- [Common Use Cases](#common-use-cases)
 - [Communication](#communication)
+- [Documentation](#documentation)
 - [Contributing](#contributing)
 - [Author](#author)
 - [Dependencies](#dependencies)
 - [License](#license)
 
-## Usage
+## Requirements
+
+| Platform  | Minimum Version |
+|-----------|----------------|
+| iOS       | 13.0+          |
+| macOS     | 10.15+         |
+| tvOS      | 13.0+          |
+| watchOS   | 7.0+           |
+| visionOS  | 1.0+           |
+| Xcode     | 15.3+          |
+| Swift     | 5.10+           |
+
+## Installation
+
+### Swift Package Manager
+
+Add the following dependency to your `Package.swift`:
+
+```swift
+dependencies: [
+    .package(url: "https://github.com/space-code/network-layer.git", from: "1.0.0")
+]
+```
+
+Or add it through Xcode:
+
+1. File > Add Package Dependencies
+2. Enter package URL: `https://github.com/space-code/network-layer.git`
+3. Select version requirements
+
+## Architecture
+
+NetworkLayer consists of two packages:
+
+- **NetworkLayer** - Core functionality including request processing, session management, and response handling
+- **NetworkLayerInterfaces** - Protocol definitions and interfaces for extensibility and testing
+
+This separation allows for better modularity and makes it easy to mock components during testing.
+
+## Quick Start
 
 ```swift
 import NetworkLayer
 import NetworkLayerInterfaces
 
-struct Request: IRequest {
-    var domainName: String { 
-        "https://example.com"
+// Define your request
+struct UserRequest: IRequest {
+    let userId: String
+    
+    var domainName: String { "https://api.example.com" }
+    var path: String { "users/\(userId)" }
+    var httpMethod: HTTPMethod { .get }
+}
+
+// Make the request
+let requestProcessor = NetworkLayerAssembly().assemble()
+
+do {
+    let response: Response<User> = try await requestProcessor.send(UserRequest(userId: "123"))
+    print("✅ User fetched: \(response.value.name)")
+} catch {
+    print("❌ Request failed: \(error)")
+}
+```
+
+## Usage
+
+### Basic Requests
+
+Define requests by conforming to the `IRequest` protocol:
+
+```swift
+import NetworkLayerInterfaces
+
+struct GetPostsRequest: IRequest {
+    var domainName: String { "https://jsonplaceholder.typicode.com" }
+    var path: String { "posts" }
+    var httpMethod: HTTPMethod { .get }
+}
+
+struct CreatePostRequest: IRequest {
+    let title: String
+    let body: String
+    let userId: Int
+    
+    var domainName: String { "https://jsonplaceholder.typicode.com" }
+    var path: String { "posts" }
+    var httpMethod: HTTPMethod { .post }
+    var body: RequestBody? {
+        .dictionary([
+            "title": title,
+            "body": body,
+            "userId": userId
+        ])
     }
+}
+
+// Usage
+let requestProcessor = NetworkLayerAssembly().assemble()
+
+// GET request
+let posts: Response<[Post]> = try await requestProcessor.send(GetPostsRequest())
 
-    var path: String { 
-        "user"
+// POST request
+let newPost: Response<Post> = try await requestProcessor.send(
+    CreatePostRequest(title: "Hello", body: "World", userId: 1)
+)
+```
+
+### Authentication
+
+NetworkLayer supports authentication through the `IAuthenticationInterceptor` protocol:
+
+```swift
+import NetworkLayerInterfaces
+
+class BearerTokenInterceptor: IAuthenticationInterceptor {
+    private var token: String?
+    
+    func adapt(request: inout URLRequest, for session: URLSession) async throws {
+        if let token = token {
+            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        }
+    }
+    
+    func isRequireRefresh(_ request: URLRequest, response: HTTPURLResponse) -> Bool {
+        response.statusCode == 401
     }
+    
+    func refresh(_ request: URLRequest, with response: HTTPURLResponse, for session: URLSession) async throws {
+        // Implement token refresh logic
+        token = try await refreshToken()
+    }
+}
+
+// Configure with authentication
+let configuration = Configuration(
+    sessionConfiguration: .default,
+    interceptor: BearerTokenInterceptor()
+)
+
+let requestProcessor = NetworkLayerAssembly().assemble(configuration: configuration)
+
+// Requests requiring authentication
+struct SecureRequest: IRequest {
+    var domainName: String { "https://api.example.com" }
+    var path: String { "secure/data" }
+    var httpMethod: HTTPMethod { .get }
+    var requiresAuthentication: Bool { true }
+}
+```
 
-    var httpMethod: HTTPMethod { 
-        .get
+### Retry Policies
+
+Leverage [Typhoon](https://github.com/space-code/typhoon) for sophisticated retry strategies:
+
+```swift
+import Typhoon
+
+// Configure retry policy during assembly
+let requestProcessor = NetworkLayerAssembly(
+    retryStrategy: .custom(
+        .exponentialWithJitter(
+            retry: 3,
+            jitterFactor: 0.2,
+            maxInterval: .seconds(30),
+            multiplier: 2.0,
+            duration: .seconds(1)
+        )
+    )
+).assemble()
+
+// Per-request retry strategy override
+let response: Response<Data> = try await requestProcessor.send(
+    request,
+    strategy: .constant(retry: 5, duration: .seconds(2))
+)
+
+// Custom retry evaluation
+let response: Response<User> = try await requestProcessor.send(
+    request,
+    shouldRetry: { error in
+        // Only retry on network errors, not on validation failures
+        if let networkError = error as? URLError {
+            return networkError.code == .timedOut || networkError.code == .networkConnectionLost
+        }
+        return false
+    }
+)
+```
+
+### Custom Configuration
+
+Customize the network layer to fit your needs:
+
+```swift
+import NetworkLayer
+import NetworkLayerInterfaces
+
+class CustomDelegate: RequestProcessorDelegate {
+    func requestProcessor(
+        _ processor: IRequestProcessor,
+        willSendRequest request: URLRequest
+    ) async throws {
+        print("Sending request to: \(request.url?.absoluteString ?? "")")
+    }
+    
+    func requestProcessor(
+        _ processor: IRequestProcessor,
+        validateResponse response: HTTPURLResponse,
+        data: Data,
+        task: URLSessionTask
+    ) throws {
+        guard (200...299).contains(response.statusCode) else {
+            throw NetworkLayerError.invalidStatusCode(response.statusCode)
+        }
     }
 }
 
-let request = Request()
-let requestProcessor = NetworkLayerAssembly().assemble()
-let user: User = try await requestProcessor.send(request)
+let configuration = Configuration(
+    sessionConfiguration: .default,
+    sessionDelegate: CustomSessionDelegate(),
+    sessionDelegateQueue: .main,
+    jsonDecoder: JSONDecoder(),
+    interceptor: BearerTokenInterceptor()
+)
+
+let requestProcessor = NetworkLayerAssembly().assemble(
+    configuration: configuration,
+    delegate: CustomDelegate()
+)
 ```
 
-## Documentation
+### Request Validation
 
-Check out [network-layer documentation](https://github.com/space-code/network-layer/blob/main/Sources/NetworkLayer/NetworkLayer.docc/NetworkLayer.md).
+Add custom validation logic for responses:
 
-## Requirements
-- iOS 13.0+ / macOS 10.15+ / tvOS 13.0+ / watchOS 7.0+ / visionOS 1.0+
-- Xcode 14.0
-- Swift 5.7
+```swift
+class ValidationDelegate: RequestProcessorDelegate {
+    func requestProcessor(
+        _ processor: IRequestProcessor,
+        validateResponse response: HTTPURLResponse,
+        data: Data,
+        task: URLSessionTask
+    ) throws {
+        // Check status code
+        guard (200...299).contains(response.statusCode) else {
+            throw APIError.invalidStatusCode(response.statusCode)
+        }
+        
+        // Check content type
+        guard let contentType = response.value(forHTTPHeaderField: "Content-Type"),
+              contentType.contains("application/json") else {
+            throw APIError.invalidContentType
+        }
+        
+        // Check response size
+        guard data.count > 0 else {
+            throw APIError.emptyResponse
+        }
+    }
+}
+```
 
-## Installation
-### Swift Package Manager
+## Common Use Cases
 
-The [Swift Package Manager](https://swift.org/package-manager/) is a tool for automating the distribution of Swift code and is integrated into the `swift` compiler. It is in early development, but `network-layer` does support its use on supported platforms.
+### REST API Client
 
-Once you have your Swift package set up, adding `network-layer` as a dependency is as easy as adding it to the `dependencies` value of your `Package.swift`.
+```swift
+import NetworkLayer
+import NetworkLayerInterfaces
+
+class APIClient {
+    private let requestProcessor: IRequestProcessor
+    
+    init() {
+        requestProcessor = NetworkLayerAssembly(
+            retryStrategy: .custom(
+                .exponentialWithJitter(
+                    retry: 3,
+                    jitterFactor: 0.2,
+                    maxInterval: .seconds(30),
+                    multiplier: 2.0,
+                    duration: .seconds(1)
+                )
+            )
+        ).assemble()
+    }
+    
+    func fetchUser(id: String) async throws -> User {
+        struct UserRequest: IRequest {
+            let id: String
+            var domainName: String { "https://api.example.com" }
+            var path: String { "users/\(id)" }
+            var httpMethod: HTTPMethod { .get }
+        }
+        
+        let response: Response<User> = try await requestProcessor.send(
+            UserRequest(id: id)
+        )
+        return response.value
+    }
+    
+    func updateUser(_ user: User) async throws -> User {
+        struct UpdateUserRequest: IRequest {
+            let user: User
+            var domainName: String { "https://api.example.com" }
+            var path: String { "users/\(user.id)" }
+            var httpMethod: HTTPMethod { .put }
+            var body: RequestBody? {
+                .encodable(user)
+            }
+        }
+        
+        let response: Response<User> = try await requestProcessor.send(
+            UpdateUserRequest(user: user)
+        )
+        return response.value
+    }
+}
+```
+
+### Authenticated API Client
 
 ```swift
-dependencies: [
-    .package(url: "https://github.com/space-code/network-layer.git", .upToNextMajor(from: "1.0.0"))
-]
+import NetworkLayer
+import NetworkLayerInterfaces
+
+class SecureAPIClient {
+    private let requestProcessor: IRequestProcessor
+    
+    init(authToken: String) {
+        class AuthInterceptor: IAuthenticationInterceptor {
+            var token: String
+            
+            init(token: String) {
+                self.token = token
+            }
+            
+            func adapt(request: inout URLRequest, for session: URLSession) async throws {
+                request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+            }
+            
+            func isRequireRefresh(_ request: URLRequest, response: HTTPURLResponse) -> Bool {
+                response.statusCode == 401
+            }
+            
+            func refresh(_ request: URLRequest, with response: HTTPURLResponse, for session: URLSession) async throws {
+                // Refresh token logic
+            }
+        }
+        
+        let configuration = Configuration(
+            sessionConfiguration: .default,
+            interceptor: AuthInterceptor(token: authToken)
+        )
+        
+        requestProcessor = NetworkLayerAssembly().assemble(configuration: configuration)
+    }
+    
+    func fetchPrivateData() async throws -> PrivateData {
+        struct PrivateDataRequest: IRequest {
+            var domainName: String { "https://api.example.com" }
+            var path: String { "private/data" }
+            var httpMethod: HTTPMethod { .get }
+            var requiresAuthentication: Bool { true }
+        }
+        
+        let response: Response<PrivateData> = try await requestProcessor.send(
+            PrivateDataRequest()
+        )
+        return response.value
+    }
+}
 ```
 
 ## Communication
-- If you **found a bug**, open an issue.
-- If you **have a feature request**, open an issue.
-- If you **want to contribute**, submit a pull request.
+
+- 🐛 **Found a bug?** [Open an issue](https://github.com/space-code/network-layer/issues/new)
+- 💡 **Have a feature request?** [Open an issue](https://github.com/space-code/network-layer/issues/new)
+- ❓ **Questions?** [Start a discussion](https://github.com/space-code/network-layer/discussions)
+- 🔒 **Security issue?** Email nv3212@gmail.com
+
+## Documentation
+
+Comprehensive documentation is available: [NetworkLayer Documentation](https://github.com/space-code/network-layer/blob/main/Sources/NetworkLayer/NetworkLayer.docc/NetworkLayer.md)
 
 ## Contributing
-Bootstrapping development environment
 
-```
-make bootstrap
-```
+We love contributions! Please feel free to help out with this project. If you see something that could be made better or want a new feature, open up an issue or send a Pull Request.
 
-Please feel free to help out with this project! If you see something that could be made better or want a new feature, open up an issue or send a Pull Request!
+### Development Setup
+
+Bootstrap the development environment:
+
+```bash
+mise install
+```
 
 ## Author
-Nikita Vasilev, nv3212@gmail.com
+
+**Nikita Vasilev**
+- Email: nv3212@gmail.com
+- GitHub: [@ns-vasilev](https://github.com/ns-vasilev)
 
 ## Dependencies
+
 This project uses several open-source packages:
 
-* [Atomic](https://github.com/space-code/atomic) is a Swift property wrapper designed to make values thread-safe.
-* [Typhoon](https://github.com/space-code/typhoon) is a service for retry policies.
-* [Mocker](https://github.com/WeTransfer/Mocker) is a library written in Swift which makes it possible to mock data requests using a custom `URLProtocol`.
+* [Atomic](https://github.com/space-code/atomic) - A Swift property wrapper designed to make values thread-safe
+* [Typhoon](https://github.com/space-code/typhoon) - A service for retry policies with multiple strategies
+* [Mocker](https://github.com/WeTransfer/Mocker) - A library for mocking data requests using a custom URLProtocol
 
 ## License
-network-layer is available under the MIT license. See the LICENSE file for more info.
+
+network-layer is available under the MIT license. See the [LICENSE](https://github.com/space-code/network-layer/blob/main/LICENSE) file for more info.
+
+---
+
+<div align="center">
+
+**[⬆ back to top](#network-layer)**
+
+Made with ❤️ by [space-code](https://github.com/space-code)
+
+</div>
\ No newline at end of file
diff --git a/hooks/pre-commit b/hooks/pre-commit
deleted file mode 100755
index 956fdcb..0000000
--- a/hooks/pre-commit
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/bin/bash
-git diff --diff-filter=d --staged --name-only | grep -e '\.swift$' | while read line; do
-  if [[ $line == *"/Generated"* ]]; then
-    echo "IGNORING GENERATED FILE: " "$line";
-  else
-    mint run swiftformat swiftformat "${line}";
-    git add "$line";
-  fi
-done
-
-LINT=$(which mint)
-if [[ -e "${LINT}" ]]; then
-    # Export files in SCRIPT_INPUT_FILE_$count to lint against later
-    count=0
-    while IFS= read -r file_path; do
-        export SCRIPT_INPUT_FILE_$count="$file_path"
-        count=$((count + 1))
-    done < <(git diff --name-only --cached --diff-filter=d | grep ".swift$")
-    export SCRIPT_INPUT_FILE_COUNT=$count
-
-    if [ "$count" -eq 0 ]; then
-        echo "No files to lint!"
-        exit 0
-    fi
-
-    echo "Found $count lintable files! Linting now.."
-    mint run swiftlint --use-script-input-files --strict --config .swiftlint.yml
-    RESULT=$? # swiftline exit value is number of errors
-
-    if [ $RESULT -eq 0 ]; then
-        echo "🎉  Well done. No violation."
-    fi
-    exit $RESULT
-else
-    echo "⚠️  WARNING: SwiftLint not found"
-    echo "⚠️  You might want to edit .git/hooks/pre-commit to locate your swiftlint"
-    exit 0
-fi
\ No newline at end of file

From 9dfb73ad848fe5f993f8d354e3256ec4eca84a30 Mon Sep 17 00:00:00 2001
From: Nikita Vasilev <nv3212@gmail.com>
Date: Sun, 21 Dec 2025 21:02:30 +0400
Subject: [PATCH 2/2] docs: generate DocC

---
 .github/workflows/release.yml | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 0ca7a11..e83f17c 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -123,14 +123,20 @@ jobs:
         with:
           version: ${{ needs.release.outputs.next-version }}
           project-name: 'NetworkLayer'
-          project-description: 'NetworkLayer is a modern, lightweight Swift framework that provides elegant and robust retry policies for asynchronous operations.'
+          project-description: 'NetworkLayer is a modern, type-safe Swift framework for elegant network communication. Built with async/await and actor-based architecture for thread-safe request processing.'
           modules: |
             [
               {
                 "name": "NetworkLayer",
                 "path": "networklayer",
-                "description": "Core retry mechanisms and policies for asynchronous operations. Includes retry strategies, backoff algorithms, and cancellation support.",
+                "description": "Core networking functionality including request processing, authentication handling, retry policies, and session management. Features thread-safe actor-based architecture.",
                 "badge": "Core Module"
+              },
+              {
+                "name": "NetworkLayerInterfaces",
+                "path": "networklayerinterfaces",
+                "description": "Protocol definitions and public interfaces for extensibility and testing. Includes IRequest, IRequestProcessor, and IAuthenticationInterceptor protocols.",
+                "badge": "Interfaces"
               }
             ]
       - name: Deploy