Production-grade TypeScript API testing framework with fluent DSL
npm install restifiedtstypescript
describe('Database Validation', function() {
it('should validate user data', function() {
const user = { id: 1, name: 'John', active: true };
// All assertions automatically captured with proper expected/actual values
expect(user.id).to.equal(1); // Expected: 1, Actual: 1
expect(user.name).to.include('John'); // Expected: to include John, Actual: John
assert.strictEqual(user.active, true); // Expected: true, Actual: true
// HTML report shows all assertions with detailed comparison data
});
});
`
$3
`bash
Enable assertion capture debugging
DEBUG_RESTIFIED_ASSERTIONS=true npm test
Enable HTML reporter debugging
DEBUG_RESTIFIED_REPORTER=true npm test
Output shows detailed assertion capture process:
🎯 Started capturing external assertions for test: Database Test
✅ Hooked into Chai expect()
➕ Captured external assertion: expect(42).to.equal(42)
🔍 Merged 3 external assertions into test result
`
🆕 What's New in v2.3.0 - Advanced Performance Suite
$3
- 🔄 Request Deduplication: Eliminate 20-40% of duplicate concurrent requests automatically
- 💾 Response Caching: Smart caching with LRU/LFU/FIFO strategies achieving 60-90% cache hit rates
- 📦 Request Batching: Combine multiple calls for 50-80% reduction in network operations
- 🌊 Streaming Support: Handle 10x larger datasets with 90% less memory usage
- 🔄 Error Recovery: Graceful degradation with fallback strategies and service level management
$3
- AdvancedPerformanceManager: Central orchestrator for all performance optimizations
- Intelligent Deduplication: Request fingerprinting prevents redundant concurrent calls
- Multi-Strategy Caching: TTL-based caching with automatic eviction and invalidation
- Memory-Efficient Streaming: Chunk-based processing with backpressure control
- Real-time Metrics: Comprehensive performance monitoring and statistics
$3
`typescript
// Enable all performance optimizations
restified.given()
.advancedPerformance({
enabled: true,
deduplication: { enabled: true, maxWaitTime: 30000 },
caching: { enabled: true, maxCacheSize: 1000, defaultTtl: 300000 },
batching: { enabled: true, maxBatchSize: 10, batchTimeout: 100 },
streaming: { enabled: true, chunkSize: 65536 }
})
.baseURL('https://api.example.com')
.when()
.get('/users')
`
$3
| Feature | Performance Gain | Use Case |
| ------------------------------- | --------------------- | ----------------------------- |
| Request Deduplication | 20-40% fewer calls | Concurrent identical requests |
| Response Caching | 60-90% cache hits | Repeated API calls |
| Request Batching | 50-80% fewer requests | Multiple similar operations |
| Streaming Support | 90% memory reduction | Large dataset processing |
$3
- 🚀 Virtual Scrolling: Revolutionary HTML reports handling 3000+ tests
- ⚡ Smart Data Loading: On-demand loading prevents browser freeze
- 📊 Performance Indicators: Visual feedback for optimization status
- 💾 Zero Data Loss: All test data preserved with responsive UI
$3
No changes required! All existing commands work exactly the same:
`bash
Same commands, enhanced performance
npm run report:restified
restifiedts scaffold -n "MyAPI" -u "https://api.example.com"
`
$3
- ✅ scaffold command creates folder with project name (not generic "tests" folder)
- ✅ Enhanced ConfigLoader with enterprise validation and graceful fallbacks
- ✅ 50+ new environment variables for complete customization
- ✅ Better TypeScript integration and error handling
- 🆕 Security-hardened CLI: All commands now validate inputs for safety
- 🆕 Path traversal protection: Prevents ../../../ directory attacks
- 🆕 Command injection prevention: Blocks malicious shell commands
- 🆕 AI-powered initialization: Enhanced init --interactive command with intelligent recommendations (replaces create --interactive)
- 🆕 Async file operations: Non-blocking file operations for better performance
---
✨ Why RestifiedTS?
RestifiedTS is inspired by Java's RestAssured but built for the modern TypeScript ecosystem with enterprise-first design:
- 🏢 Enterprise-Ready: Multi-tenant, microservices, SSO, compliance out of the box
- 🔄 Configuration-Driven: Zero boilerplate with restified.config.ts
- 🔐 Automatic Authentication: ✅ FULLY FUNCTIONAL - SSO/OAuth2 with automatic token injection
- ⚡ High-Performance: HTTP/2 connection pooling for 20-40% faster requests
- 🔄 Smart Retry System: Exponential backoff with jitter for maximum reliability
- 🛡️ Circuit Breaker Pattern: Prevent cascade failures and protect downstream services
- 🧠 Timeout Intelligence: Context-aware timeouts with adaptive learning and pattern recognition
- 📊 Comprehensive Reporting: HTML, JSON, XML, JUnit, Excel with CI/CD integration
- 🚀 Performance & Security: Built-in K6, Artillery, and OWASP ZAP integration
- 🌐 Multi-Client: Test multiple microservices with shared authentication
---
🚀 Quick Start
$3
`bash
Install RestifiedTS globally
npm install -g restifiedts
`
$3
`bash
🆕 RECOMMENDED: Interactive wizard with AI-powered analysis
restifiedts init --interactive
Follow the prompts for intelligent project setup with API analysis
OR: Traditional scaffolding approach
restifiedts scaffold -n "MyAPI" -t "api,auth,database,performance" -u "https://api.example.com"
Navigate to generated project
cd ./MyAPI
Install dependencies and run tests
npm install
npm test
`
$3
`bash
Clone for framework development
git clone https://github.com/yourorg/restifiedts.git
cd restifiedts
npm install && npm run build
Run comprehensive examples
npm run examples
`
$3
`typescript
import { restified } from "restifiedts";
describe("API Tests", function () {
it("should get user data", async function () {
const response = await restified
.given()
.useClient("api") // Pre-configured with auth & headers
.when()
.get("/users/1")
.execute();
await response
.statusCode(200)
.jsonPath("$.name", "Leanne Graham")
.execute();
// Step 1: Start capturing external assertions
response.startCapturing();
// Step 2: Get the wrapped expect function from response
const expect = response.expect; // This provides Chai expect with capture
// Step 3: Use normal Chai syntax - assertions will be automatically captured
expect(responseData.id).to.equal(1);
expect(responseData.name).to.be.a("string");
expect(responseData.email).to.contain("@");
expect(responseData.website).to.match(/\w+\.\w+/);
// Step 4: Finish capturing and include in RestifiedTS HTML report
const captured = await response.finishCapturing();
});
});
`
---
🏢 Enterprise Features
$3
`typescript
// restified.config.ts - Configure once, use everywhere
clients: {
api: { baseURL: 'https://api.company.com' },
userService: { baseURL: 'https://users.company.com' },
orderService: { baseURL: 'https://orders.company.com' },
paymentGateway: { baseURL: 'https://payments.company.com' }
}
`
$3
NEW: Automatic authentication is now fully implemented and working! No more manual auth setup required.
`typescript
// ✅ Authenticate once, use everywhere - WORKS AUTOMATICALLY!
authentication: {
endpoint: '/login',
method: 'POST',
client: 'api',
// Login credentials
credentials: {
login: 'admin@gmail.com',
password: 'ABCD123'
// Or use username/password if your API requires it
},
// Extract data from auth response
extractors: {
token: '$.access_token', // ✅ Auto-extracted
userEmail: '$.user.email', // ✅ Available as globalUserEmail
userId: '$.user.id', // ✅ Available as globalUserId
roles: '$.user.roles', // ✅ Available as globalRoles
permissions: '$.user.permissions', // ✅ Available as globalPermissions
refreshToken: '$.refresh_token' // ✅ Auto-managed token refresh
},
// ✅ AUTOMATIC: Tokens applied to clients instantly
autoApplyToClients: 'all', // Apply to all clients
authHeaderName: 'Authorization', // ✅ Configurable header name
// ✅ NEW: Enterprise features
fallback: { // ✅ CI/CD fallback tokens
token: process.env.FALLBACK_TOKEN || 'dev-token'
},
enableTokenRefresh: true, // ✅ Automatic token refresh
tokenRefreshThreshold: 300 // ✅ Refresh 5 min before expiry
}
`
🎯 What happens automatically:
1. Authentication Request: Executes on startup/config load
2. Token Extraction: Uses JSONPath extractors to get tokens
3. Client Application: Adds Authorization: Bearer to specified clients
4. Global Variables: Stores globalAuthToken, globalRefreshToken, globalUserEmail etc.
5. Fallback Handling: Uses fallback tokens if auth fails
6. Token Refresh: Automatically refreshes tokens before expiry
📝 Simplified Test Setup:
`typescript
// setup.ts - SUPER SIMPLE NOW!
before(async function() {
await restified.loadConfigFromFile(); // ✅ Auth happens automatically
await restified.initializeAuthentication(); // ✅ Wait for completion
console.log('✅ Authenticated and ready!');
});
`
$3
`typescript
// Automatic enterprise headers on all requests
globalHeaders: {
'X-Tenant-ID': process.env.TENANT_ID,
'X-Trace-ID': '{{$random.uuid}}',
'X-Compliance-Mode': 'strict'
}
`
---
🌟 Multi-Protocol Support
RestifiedTS supports comprehensive testing across multiple protocols and technologies:
$3
`typescript
// Create GraphQL client
restified.createGraphQLClient('graphql', {
endpoint: 'https://api.example.com/graphql',
headers: { 'Authorization': 'Bearer {{token}}' }
});
// Execute GraphQL queries and mutations
const response = await restified.getGraphQLClient('graphql')
.query(
, { id: '123' });
`
$3
`typescript
// Create WebSocket client
restified.createWebSocketClient('ws', {
url: 'wss://api.example.com/ws',
reconnectAttempts: 3
});
// Connect and test real-time communication
await restified.connectWebSocket('ws');
const client = restified.getWebSocketClient('ws');
await client.sendJSON({ type: 'subscribe', channel: 'orders' });
const message = await client.waitForMessage(
(msg) => msg.data.type === 'order_update',
5000
);
`
$3
> Current Status: All major database types now have complete implementations with enterprise-grade features.
`typescript
// ✅ PostgreSQL - Complete Implementation
await restified.createDatabaseClient('postgres', {
type: 'postgresql',
host: 'localhost',
port: 5432,
database: 'testdb',
username: 'postgres',
password: 'password',
connectionString: 'postgresql://postgres:password@localhost:5432/testdb',
timeout: 30000,
pool: {
min: 1,
max: 10,
idleTimeoutMillis: 30000,
acquireTimeoutMillis: 60000
},
options: {
ssl: false,
application_name: 'RestifiedTS',
schema: 'public'
}
});
// ✅ MySQL - Complete Implementation
await restified.createDatabaseClient('mysql', {
type: 'mysql',
host: 'localhost',
port: 3306,
database: 'testdb',
username: 'root',
password: 'password',
timeout: 60000,
pool: { min: 1, max: 10 },
options: {
charset: 'utf8mb4',
timezone: 'UTC',
ssl: false,
multipleStatements: false,
reconnect: true
}
});
// ✅ MongoDB - Complete Implementation
await restified.createDatabaseClient('mongo', {
type: 'mongodb',
connectionString: 'mongodb://localhost:27017/testdb',
// OR individual options:
host: 'localhost',
port: 27017,
database: 'testdb',
username: 'mongouser',
password: 'mongopass',
timeout: 30000,
options: {
authSource: 'admin',
maxPoolSize: 10,
retryWrites: true
}
});
// ✅ SQLite - Complete Implementation
await restified.createDatabaseClient('sqlite', {
type: 'sqlite',
options: {
filename: './test.db', // File path or ':memory:'
memory: false, // In-memory database
readonly: false, // Read-only mode
timeout: 5000, // Busy timeout
journalMode: 'WAL', // Journal mode
synchronous: 'NORMAL', // Sync mode
pragmas: { // Custom PRAGMA settings
'foreign_keys': 'ON',
'journal_size_limit': 67108864
}
}
});
// ✅ Redis - Complete Implementation
await restified.createDatabaseClient('redis', {
type: 'redis',
host: 'localhost',
port: 6379,
password: 'redispass',
timeout: 10000,
options: {
database: 0,
keyPrefix: 'app:',
maxRetriesPerRequest: 3,
lazyConnect: true,
commandTimeout: 5000
}
});
// ✅ SQL Server - Complete Implementation
await restified.createDatabaseClient('mssql', {
type: 'mssql',
host: 'localhost',
port: 1433,
database: 'testdb',
username: 'sa',
password: 'YourStrong!Passw0rd',
timeout: 15000,
pool: { min: 0, max: 10 },
options: {
encrypt: true,
trustServerCertificate: true,
enableArithAbort: true,
requestTimeout: 30000
}
});
// 🚀 Enhanced Database Operations
// Setup test data across multiple databases
await restified.setupDatabaseState([
{
client: 'postgres',
action: 'execute',
sql: 'CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name VARCHAR(100), email VARCHAR(100))'
},
{
client: 'postgres',
action: 'insert',
table: 'users',
data: [
{ name: 'Alice', email: 'alice@example.com' },
{ name: 'Bob', email: 'bob@example.com' }
]
},
{
client: 'redis',
action: 'execute',
sql: 'SET user:alice:session active EX 3600'
}
]);
// Comprehensive validation across databases
const validation = await restified.validateDatabaseState([
{
client: 'postgres',
table: 'users',
expectedCount: 2
},
{
client: 'postgres',
customQuery: 'SELECT COUNT(*) as count FROM users WHERE email LIKE $1',
expectedResult: { count: { min: 1 } }
},
{
client: 'redis',
customQuery: 'EXISTS user:alice:session'
}
]);
console.log('Validation result:', validation.success);
// Database health monitoring
const health = await restified.databaseHealthCheck();
console.log('Database health:', health);
// Cleanup after tests
await restified.cleanupDatabaseState([
{
client: 'postgres',
action: 'execute',
sql: 'DROP TABLE IF EXISTS users'
},
{
client: 'redis',
action: 'execute',
sql: 'DEL user:alice:session'
}
]);
// Always disconnect when done
await restified.disconnectAllDatabases();
`
$3
| Database | Status | Package Required | Features |
| ----------------------- | ----------- | -------------------------- | ----------------------------------------------------------------- |
| PostgreSQL | ✅ Complete | pg | Connection pooling, transactions, schemas, performance monitoring |
| MySQL/MariaDB | ✅ Complete | mysql2 | Connection pooling, SSL, multiple statements, bulk operations |
| MongoDB | ✅ Complete | mongodb | Replica sets, aggregation, GridFS, transactions |
| SQLite | ✅ Complete | sqlite3 | In-memory/file, WAL mode, custom functions, backup/restore |
| Redis | ✅ Complete | redis | Clustering, pipelines, key patterns, data types |
| SQL Server | ✅ Complete | mssql | Windows auth, encryption, bulk operations, stored procedures |
| Oracle | 🚧 Planned | oracledb | Enterprise features, wallet support |
| Elasticsearch | 🚧 Planned | @elastic/elasticsearch | Search operations, indexing |
$3
`bash
Install RestifiedTS
npm install restifiedts
Install database drivers as needed
npm install pg # PostgreSQL
npm install mysql2 # MySQL/MariaDB
npm install mongodb # MongoDB
npm install sqlite3 # SQLite
npm install redis # Redis
npm install mssql # SQL Server
`
$3
`typescript
// Load and resolve JSON fixtures with variables
const userData = restified.loadJsonFixture('./fixtures/user.json');
// Resolve complex nested objects
const template = {
user: {
id: '{{userId}}',
name: '{{$faker.person.fullName}}',
settings: {
theme: '{{userTheme}}',
language: '{{$env.DEFAULT_LANGUAGE}}'
}
},
metadata: {
timestamp: '{{$date.now}}',
requestId: '{{$random.uuid}}'
}
};
const resolved = restified.resolveVariables(template);
`
Supported Variable Types:
- Global/Local/Extracted: {{userId}}, {{authToken}}
- Faker.js: {{$faker.person.fullName}}, {{$faker.internet.email}}
- Random: {{$random.uuid}}, {{$random.number(1,100)}}
- Date/Time: {{$date.now}}, {{$date.timestamp}}
- Environment: {{$env.API_KEY}}
- Enterprise Utilities: {{$util.string.toUpperCase(hello)}}, {{$util.crypto.sha256(data)}}, {{$util.date.addDays({{now}}, 7, "YYYY-MM-DD")}}
$3
Generate comprehensive test suites with:
`bash
restifiedts scaffold -t "api,auth,graphql,websocket,database,performance,security"
`
- api - REST API testing with full HTTP method support
- auth - Authentication flows and token management
- graphql - GraphQL queries, mutations, and schema introspection
- websocket - Real-time WebSocket communication testing
- database - Database state validation and consistency checks
- performance - Load testing with K6 and Artillery integration
- security - Security testing with OWASP ZAP integration
---
📚 Documentation
$3
- 🚀 Quick Start Guide
- 📖 Basic Concepts
- ⚙️ Installation
$3
- 🔧 Configuration Guide
- 🔐 Authentication Setup
- 🏢 Enterprise Features
$3
- 📊 Reporting & Analytics
- 👤 User Guide
- 🛡️ Security
- 🔒 CLI Security Guide - New!
$3
- 🤝 Contributing
- 📝 Changelog
- 🔧 Claude AI Instructions
- 🏢 CLI Architecture
- 🔐 NEW: Automatic Authentication Implementation Guide
---
🎯 Core Features
$3
`typescript
const response = await restified
.given()
.baseURL('https://api.example.com')
.headers({ 'X-API-Key': 'secret' })
.variable('userId', 123)
.when()
.get('/users/{{userId}}')
.execute();
await response
.statusCode(200)
.jsonPath('$.name', 'Expected Name')
.extract('$.id', 'extractedUserId')
.execute();
`
$3
`typescript
// HTTP/2 connection pooling for faster requests
const response = await restified
.given()
.connectionPool({
keepAlive: true,
maxSockets: 50,
http2: true
})
.baseURL('https://api.example.com')
.when()
.get('/users')
.execute();
// Monitor performance metrics
const metrics = restified.getConnectionMetrics();
console.log(${metrics.cacheHitRatio}% connection reuse);
`
$3
`typescript
// Intelligent retry with comprehensive monitoring
const response = await restified
.given()
.retry({
enabled: true,
maxAttempts: 3,
baseDelay: 1000,
retryOnStatusCodes: [429, 500, 502, 503, 504]
})
.baseURL('https://api.example.com')
.when()
.get('/users')
.execute();
// Monitor retry statistics
const retryStats = restified.getRetryStats();
console.log(${retryStats.successAfterRetry} successful retries);
`
$3
`typescript
await response
.statusCode(200)
.header('Content-Type', 'application/json')
.jsonPath('$.data[*].id', (ids) => ids.length > 0)
.jsonSchema(userSchema)
.responseTime((time) => time < 500)
.execute();
`
$3
RestifiedTS provides three flexible approaches for adding delays in your API tests:
#### 🔗 1. Independent Sleep/Wait (Between DSL Calls)
`typescript
// Between requests or anywhere in test flow
const response1 = await restified.given()
.baseURL('https://api.example.com')
.when()
.get('/users/1')
.execute();
response1.statusCode(200);
// Independent sleep - not part of DSL chain
await restified.sleep(2000); // 2 seconds
await restified.wait(1000); // 1 second (alias for sleep)
// Continue with next request
const response2 = await restified.given()
.baseURL('https://api.example.com')
.when()
.get('/users/2')
.execute();
response2.statusCode(200);
`
#### ⚡ 2. WhenStep Sleep (Before HTTP Request)
`typescript
// Sleep accumulates in WhenStep before making HTTP request
const response = await restified.given()
.baseURL('https://api.example.com')
.when()
.sleep(2000) // 2 seconds
.wait(1000) // + 1 second
.sleep(2000) // + 2 seconds = 5 seconds total
.get('/users/delayed') // HTTP request happens after 5-second delay
.execute();
response.statusCode(200);
`
#### ✨ 3. ThenStep Sleep (After Assertions)
`typescript
// Sleep after assertions for timing-sensitive scenarios
const response = await restified.given()
.baseURL('https://api.example.com')
.when()
.get('/users/process')
.execute();
// Sleep after assertions (useful for async processing)
await response
.statusCode(202) // Processing started
.jsonPath('$.status', 'processing')
.sleep(5000); // Wait 5 seconds for processing to complete
// Follow up with status check
const statusResponse = await restified.given()
.baseURL('https://api.example.com')
.when()
.get('/users/process/status')
.execute();
statusResponse.statusCode(200).jsonPath('$.status', 'completed');
`
#### 🚀 Real-World Use Cases
`typescript
// Rate limiting compliance
for (let i = 1; i <= 3; i++) {
await restified.given()
.baseURL('https://api.example.com')
.when()
.get(/users/${i})
.execute()
.then()
.statusCode(200);
// Rate limit: 1 request per second
if (i < 3) await restified.sleep(1000);
}
// Async processing workflow
await restified.given()
.baseURL('https://api.example.com')
.when()
.post('/jobs/start', { task: 'process-data' })
.execute()
.then()
.statusCode(202);
// Wait for processing
await restified.sleep(3000);
// Check job status
await restified.given()
.baseURL('https://api.example.com')
.when()
.get('/jobs/status')
.execute()
.then()
.statusCode(200)
.jsonPath('$.status', 'completed');
// Simulating user interaction delays
await restified.given()
.baseURL('https://api.example.com')
.when()
.sleep(1500) // Simulate user thinking time
.post('/cart/add', { productId: 123 })
.execute()
.then()
.statusCode(201);
await restified.sleep(2000); // User reviews cart
await restified.given()
.baseURL('https://api.example.com')
.when()
.post('/checkout/start')
.execute()
.then()
.statusCode(200);
`
#### ⚙️ Sleep Method Features
✅ Three Flexible Approaches: Independent, WhenStep, and ThenStep
✅ Accumulative WhenStep: Multiple .sleep() calls add up before HTTP request
✅ Both Aliases: .sleep() and .wait() available in all contexts
✅ Fluent API: Maintains clean method chaining
✅ Non-Breaking: Doesn't affect existing RestifiedTS functionality
✅ Type-Safe: Full TypeScript support with proper return types
✅ Use Case Optimized: Perfect for rate limiting, async processing, and user simulation
$3
RestifiedTS includes intelligent retry mechanisms with exponential backoff, jitter, and comprehensive error handling for maximum reliability in unstable network conditions.
#### 🎯 1. Basic Retry Configuration
`typescript
// Enable smart retries for better reliability
const response = await restified.given()
.retry({
enabled: true, // Enable retry mechanism (default: true)
maxAttempts: 3, // Max retry attempts (default: 3)
baseDelay: 1000, // Base delay in ms (default: 1000)
backoffMultiplier: 2, // Exponential backoff (default: 2)
enableJitter: true, // Add jitter to prevent thundering herd (default: true)
retryOnStatusCodes: [408, 429, 500, 502, 503, 504] // Retry conditions
})
.baseURL('https://api.example.com')
.when()
.get('/users')
.execute();
response.statusCode(200);
`
#### ⚡ 2. Advanced Retry Strategies
`typescript
// Custom retry conditions and callbacks
await restified.given()
.retry({
enabled: true,
maxAttempts: 5,
baseDelay: 500,
maxDelay: 30000, // Cap maximum delay at 30s
retryOnNetworkError: true,
retryOnTimeout: true,
// Custom retry condition
retryCondition: (error, attempt) => {
// Retry on specific conditions
if (error.response?.status === 429) return true; // Rate limited
if (error.code === 'ECONNREFUSED') return true; // Connection refused
if (attempt < 3 && error.response?.status >= 500) return true;
return false;
},
// Retry callback for logging/monitoring
onRetry: (error, attempt, delay) => {
console.log(🔄 Retry attempt ${attempt} after ${delay}ms: ${error.message});
},
// Max attempts callback
onMaxAttemptsReached: (error, attempts) => {
console.error(❌ Failed after ${attempts} attempts: ${error.message});
}
})
.baseURL('https://unreliable-api.example.com')
.when()
.get('/flaky-endpoint')
.execute();
`
#### 🌐 3. Global Retry Configuration
`typescript
// Configure retry behavior globally for all requests
const restifiedWithRetry = new Restified({
retry: {
enabled: true,
maxAttempts: 3,
baseDelay: 1000,
retryOnStatusCodes: [429, 500, 502, 503, 504],
retryOnNetworkError: true,
retryOnTimeout: true
},
connectionPool: {
keepAlive: true,
maxSockets: 20
}
});
// All requests automatically use the global retry configuration
const response1 = await restifiedWithRetry.given()
.baseURL('https://api1.example.com')
.when()
.get('/data')
.execute();
// Override global config for specific requests
const response2 = await restifiedWithRetry.given()
.retry({
enabled: true,
maxAttempts: 1, // Override: no retries for this request
baseDelay: 0
})
.baseURL('https://api2.example.com')
.when()
.get('/fast-endpoint')
.execute();
`
#### 📊 4. Retry Monitoring and Analytics
`typescript
// Monitor retry behavior and performance
describe('API Reliability Testing', () => {
beforeEach(() => {
restified.resetRetryStats(); // Clear stats for each test
});
it('should handle transient failures gracefully', async () => {
// Simulate multiple API calls with potential failures
const requests = [];
for (let i = 0; i < 10; i++) {
const request = restified.given()
.retry({
enabled: true,
maxAttempts: 3,
baseDelay: 200
})
.baseURL('https://api.example.com')
.when()
.get(/endpoint-${i})
.execute()
.then(response => response.statusCode(200))
.catch(error => console.log(Request ${i} failed: ${error.message}));
requests.push(request);
}
await Promise.all(requests);
// Analyze retry statistics
const retryStats = restified.getRetryStats();
console.log('📊 Retry Statistics:');
console.log( Total requests: ${retryStats.totalRequests});
console.log( Requests that needed retries: ${retryStats.retriedRequests});
console.log( Total retry attempts: ${retryStats.totalRetryAttempts});
console.log( Success after retry: ${retryStats.successAfterRetry});
console.log( Failed after max retries: ${retryStats.failedAfterMaxRetries});
// Get performance metrics and recommendations
const metrics = restified.getRetryMetrics();
console.log('📈 Performance Metrics:');
console.log( Retry rate: ${metrics.retryRate.toFixed(2)}%);
console.log( Success rate after retry: ${metrics.successRateAfterRetry.toFixed(2)}%);
console.log( Average retry delay: ${metrics.averageRetryDelay.toFixed(2)}ms);
// Get actionable recommendations
const recommendations = restified.getRetryRecommendations();
console.log('💡 Recommendations:');
recommendations.forEach((rec, i) => console.log( ${i + 1}. ${rec}));
});
});
`
#### 🏭 5. Enterprise Scenarios
`typescript
// Microservices with different retry strategies
describe('Microservices Retry Strategies', () => {
it('should use different retry configs per service', async () => {
// User service - fast retries for better UX
const userServiceConfig = {
enabled: true,
maxAttempts: 2,
baseDelay: 200,
maxDelay: 2000,
retryOnStatusCodes: [429, 502, 503]
};
// Payment service - more aggressive retries for critical operations
const paymentServiceConfig = {
enabled: true,
maxAttempts: 5,
baseDelay: 1000,
maxDelay: 10000,
retryOnStatusCodes: [408, 429, 500, 502, 503, 504],
onRetry: (error, attempt, delay) => {
console.log(💳 Payment retry ${attempt}: ${error.message});
}
};
// Analytics service - fewer retries, non-critical
const analyticsServiceConfig = {
enabled: true,
maxAttempts: 2,
baseDelay: 500,
retryOnStatusCodes: [503, 504] // Only retry on service unavailable
};
// Execute requests with service-specific retry strategies
const [userResponse, paymentResponse, analyticsResponse] = await Promise.allSettled([
restified.given()
.retry(userServiceConfig)
.baseURL('https://users.company.com')
.when()
.get('/profile')
.execute(),
restified.given()
.retry(paymentServiceConfig)
.baseURL('https://payments.company.com')
.when()
.post('/charge', { amount: 100, currency: 'USD' })
.execute(),
restified.given()
.retry(analyticsServiceConfig)
.baseURL('https://analytics.company.com')
.when()
.post('/events', { action: 'purchase', userId: 123 })
.execute()
]);
// Handle results with different expectations per service
if (userResponse.status === 'fulfilled') {
userResponse.value.statusCode(200);
}
if (paymentResponse.status === 'fulfilled') {
paymentResponse.value.statusCode(200);
}
// Analytics is optional - don't fail test if it fails
if (analyticsResponse.status === 'rejected') {
console.log('⚠️ Analytics service unavailable, continuing...');
}
});
});
// Circuit breaker pattern preparation
describe('Circuit Breaker Preparation', () => {
it('should collect failure data for circuit breaker decisions', async () => {
const failingEndpoint = '/always-fails';
const attempts = 10;
for (let i = 0; i < attempts; i++) {
try {
await restified.given()
.retry({
enabled: true,
maxAttempts: 2,
baseDelay: 100
})
.baseURL('https://api.example.com')
.when()
.get(failingEndpoint)
.execute();
} catch (error) {
// Expected failures
}
}
const retryStats = restified.getRetryStats();
const failureRate = (retryStats.failedAfterMaxRetries / retryStats.totalRequests) * 100;
console.log(🔴 Failure rate for ${failingEndpoint}: ${failureRate.toFixed(2)}%);
// Circuit breaker decision logic
if (failureRate > 50) {
console.log('🚨 Circuit breaker should OPEN - too many failures');
} else if (failureRate > 20) {
console.log('⚠️ Circuit breaker should be HALF-OPEN - monitoring');
} else {
console.log('✅ Circuit breaker CLOSED - service healthy');
}
});
});
`
#### ⚙️ Retry Configuration Options
`typescript
interface RetryConfig {
enabled?: boolean; // Enable retry mechanism (default: true)
maxAttempts?: number; // Maximum retry attempts (default: 3)
baseDelay?: number; // Base delay in ms (default: 1000)
maxDelay?: number; // Maximum delay in ms (default: 30000)
backoffMultiplier?: number; // Exponential backoff multiplier (default: 2)
enableJitter?: boolean; // Add jitter to prevent thundering herd (default: true)
jitterFactor?: number; // Jitter percentage (default: 0.1 = 10%)
retryOnStatusCodes?: number[]; // HTTP codes to retry (default: [408, 429, 500, 502, 503, 504])
retryOnNetworkError?: boolean; // Retry on network errors (default: true)
retryOnTimeout?: boolean; // Retry on timeout (default: true)
retryCondition?: (error: any, attempt: number) => boolean; // Custom retry logic
onRetry?: (error: any, attempt: number, delay: number) => void; // Retry callback
onMaxAttemptsReached?: (error: any, attempts: number) => void; // Max attempts callback
}
`
#### 🎯 Retry Benefits & Features
✅ Intelligent Backoff: Exponential backoff with jitter prevents thundering herd
✅ Configurable Conditions: Retry on specific status codes, network errors, or custom conditions
✅ Comprehensive Monitoring: Detailed statistics and performance metrics
✅ Global Configuration: Set retry behavior once, apply everywhere
✅ Per-Request Override: Fine-tune retry behavior for specific endpoints
✅ Enterprise Ready: Circuit breaker preparation, failure analysis, recommendations
✅ Callback Support: Custom logging, monitoring, and alerting integration
✅ Network Resilience: Handle timeouts, connection failures, and transient errors
✅ Performance Optimized: Jitter and delay caps prevent resource exhaustion
✅ Backward Compatible: Works seamlessly with all existing RestifiedTS features
$3
RestifiedTS includes enterprise-grade Circuit Breaker pattern implementation to prevent cascade failures and protect downstream services from being overwhelmed during outages. The circuit breaker monitors failure rates and automatically fails fast when services are unhealthy, allowing them time to recover.
#### 🎯 1. Basic Circuit Breaker Configuration
`typescript
// Enable circuit breaker for automatic failure protection
const response = await restified.given()
.circuitBreaker({
enabled: true, // Enable circuit breaker (default: true)
failureThreshold: 5, // Open after 5 consecutive failures
failureThresholdPercentage: 50, // Or 50% failure rate
requestVolumeThreshold: 10, // Minimum requests before evaluation
timeoutDuration: 30000, // Request timeout (30s)
resetTimeoutDuration: 60000, // Time before trying HALF_OPEN (60s)
halfOpenMaxAttempts: 3 // Max attempts in HALF_OPEN state
})
.baseURL('https://api.example.com')
.when()
.get('/users')
.execute();
response.statusCode(200);
`
#### ⚡ 2. Advanced Circuit Breaker with Callbacks
`typescript
// Circuit breaker with monitoring and alerting callbacks
await restified.given()
.circuitBreaker({
enabled: true,
failureThreshold: 3,
failureThresholdPercentage: 60,
requestVolumeThreshold: 5,
resetTimeoutDuration: 30000,
responseTimeThreshold: 5000, // Consider slow responses as failures
// Circuit state change callbacks for monitoring
onCircuitOpen: async (circuitId, stats) => {
console.error(🚨 CIRCUIT OPENED: ${circuitId});
console.error(Failure count: ${stats.failureCount}/${stats.totalRequests});
// Send alert to monitoring system
await sendAlert('circuit-breaker', {
event: 'OPEN',
service: circuitId,
failureRate: (stats.failureCount / stats.totalRequests * 100).toFixed(2),
timestamp: new Date().toISOString()
});
},
onCircuitClose: async (circuitId, stats) => {
console.log(✅ CIRCUIT CLOSED: ${circuitId} - Service recovered);
// Send recovery notification
await sendAlert('circuit-breaker', {
event: 'CLOSED',
service: circuitId,
timestamp: new Date().toISOString()
});
},
onCircuitHalfOpen: async (circuitId, stats) => {
console.log(🔄 CIRCUIT HALF-OPEN: ${circuitId} - Testing recovery);
}
})
.retry({
enabled: true,
maxAttempts: 2, // Reduced retries since circuit breaker handles failures
baseDelay: 1000
})
.baseURL('https://unreliable-service.example.com')
.when()
.post('/process-order', { orderId: 12345 })
.execute();
`
#### 🌐 3. Global Circuit Breaker Configuration
`typescript
// Configure circuit breaker behavior globally for all services
const restifiedWithCircuitBreaker = new Restified({
circuitBreaker: {
enabled: true,
failureThreshold: 5,
failureThresholdPercentage: 50,
requestVolumeThreshold: 10,
timeoutDuration: 30000,
resetTimeoutDuration: 60000,
responseTimeThreshold: 5000
},
retry: {
enabled: true,
maxAttempts: 2, // Circuit breaker + retry for maximum resilience
baseDelay: 500
}
});
// All requests automatically use circuit breaker protection
const response1 = await restifiedWithCircuitBreaker.given()
.baseURL('https://api1.example.com')
.when()
.get('/data')
.execute();
// Override global config for specific services
const response2 = await restifiedWithCircuitBreaker.given()
.circuitBreaker({
enabled: true,
failureThreshold: 3, // More sensitive for critical service
resetTimeoutDuration: 30000 // Faster recovery attempts
})
.baseURL('https://critical-api.example.com')
.when()
.get('/critical-operation')
.execute();
`
#### 📊 4. Circuit Breaker Monitoring and Analytics
`typescript
// Monitor circuit breaker states and performance
describe('Circuit Breaker Monitoring', () => {
it('should track circuit states and provide metrics', async () => {
// Reset circuit breaker stats for clean test
restified.resetCircuitBreakerStats();
// Simulate multiple requests to trigger circuit breaker behavior
const requests = [];
for (let i = 0; i < 20; i++) {
const request = restified.given()
.circuitBreaker({
enabled: true,
failureThreshold: 5,
requestVolumeThreshold: 3
})
.baseURL('https://flaky-api.example.com')
.when()
.get(/endpoint-${i})
.execute()
.catch(error => {
if (error.circuitBreakerState === 'OPEN') {
console.log(⚡ Fast fail: Circuit breaker is OPEN for ${error.circuitId});
}
return null;
});
requests.push(request);
}
await Promise.allSettled(requests);
// Analyze all circuits
const allCircuits = restified.getAllCircuitIds();
console.log(📊 Monitoring ${allCircuits.length} circuits:);
allCircuits.forEach(circuitId => {
const state = restified.getCircuitState(circuitId);
const stats = restified.getCircuitBreakerStats(circuitId);
const metrics = restified.getCircuitBreakerMetrics(circuitId);
console.log(\n🔌 Circuit: ${circuitId});
console.log( State: ${state});
console.log( Requests: ${stats.totalRequests});
console.log( Failures: ${stats.failureCount});
console.log( Success Rate: ${((stats.successCount / stats.totalRequests) * 100).toFixed(2)}%);
if (metrics) {
console.log( Availability: ${metrics.availabilityPercentage.toFixed(2)}%);
console.log( P95 Response Time: ${metrics.responseTimeP95}ms);
console.log( Mean Time to Recovery: ${metrics.meanTimeToRecovery}ms);
}
});
});
it('should handle circuit breaker state transitions', async () => {
const circuitId = 'GET:https://test-api.example.com';
// Force circuit open for testing
restified.forceOpenCircuit(circuitId);
expect(restified.getCircuitState(circuitId)).to.equal('OPEN');
// Test fast-fail behavior
try {
await restified.given()
.baseURL('https://test-api.example.com')
.when()
.get('/test')
.execute();
// Should not reach here
throw new Error('Expected circuit breaker to prevent request');
} catch (error) {
expect(error.circuitBreakerState).to.equal('OPEN');
expect(error.message).to.include('Circuit breaker');
}
// Force circuit closed for recovery testing
restified.forceCloseCircuit(circuitId);
expect(restified.getCircuitState(circuitId)).to.equal('CLOSED');
});
});
`
#### 🏭 5. Enterprise Microservices Protection
`typescript
// Different circuit breaker strategies per service type
describe('Microservices Circuit Breaker Strategies', () => {
it('should protect different service types appropriately', async () => {
// User service - quick recovery, user-facing
const userServiceConfig = {
enabled: true,
failureThreshold: 3,
failureThresholdPercentage: 60,
requestVolumeThreshold: 5,
timeoutDuration: 5000, // Quick timeout for UX
resetTimeoutDuration: 15000, // Fast recovery attempts
responseTimeThreshold: 2000 // Consider slow responses as failures
};
// Payment service - conservative, high reliability needed
const paymentServiceConfig = {
enabled: true,
failureThreshold: 2, // Very sensitive to failures
failureThresholdPercentage: 30,
requestVolumeThreshold: 3,
timeoutDuration: 10000, // Allow longer for payment processing
resetTimeoutDuration: 60000, // Conservative recovery
responseTimeThreshold: 8000
};
// Analytics service - tolerant, non-critical
const analyticsServiceConfig = {
enabled: true,
failureThreshold: 10, // More tolerant
failureThresholdPercentage: 80,
requestVolumeThreshold: 20,
timeoutDuration: 30000, // Allow long processing
resetTimeoutDuration: 120000, // Slow recovery is acceptable
responseTimeThreshold: 15000
};
// Execute requests with service-appropriate circuit breaker protection
const [userResponse, paymentResponse, analyticsResponse] = await Promise.allSettled([
restified.given()
.circuitBreaker(userServiceConfig)
.retry({ enabled: true, maxAttempts: 2, baseDelay: 200 })
.baseURL('https://users.company.com')
.when()
.get('/profile')
.execute(),
restified.given()
.circuitBreaker(paymentServiceConfig)
.retry({ enabled: true, maxAttempts: 3, baseDelay: 1000 })
.baseURL('https://payments.company.com')
.when()
.post('/process-payment', { amount: 100.00 })
.execute(),
restified.given()
.circuitBreaker(analyticsServiceConfig)
.retry({ enabled: true, maxAttempts: 1 }) // Minimal retries for analytics
.baseURL('https://analytics.company.com')
.when()
.post('/track-event', { event: 'user_action' })
.execute()
]);
// Analyze service health across the ecosystem
const circuits = restified.getAllCircuitIds();
const healthReport = circuits.map(circuitId => ({
service: circuitId.split(':')[1],
method: circuitId.split(':')[0],
state: restified.getCircuitState(circuitId),
metrics: restified.getCircuitBreakerMetrics(circuitId)
}));
console.log('🏥 Microservices Health Report:');
healthReport.forEach(service => {
console.log( ${service.method} ${service.service}: ${service.state});
if (service.metrics) {
console.log( Availability: ${service.metrics.availabilityPercentage.toFixed(1)}%);
}
});
});
});
`
#### 📈 6. Circuit Breaker + Retry Integration
`typescript
// Circuit breaker works seamlessly with retry system for maximum resilience
describe('Circuit Breaker + Retry Integration', () => {
it('should provide layered resilience protection', async () => {
// Layer 1: Retry system handles transient failures
// Layer 2: Circuit breaker prevents cascade failures
const response = await restified.given()
.retry({
enabled: true,
maxAttempts: 3,
baseDelay: 500,
retryOnStatusCodes: [429, 502, 503, 504]
})
.circuitBreaker({
enabled: true,
failureThreshold: 5,
failureThresholdPercentage: 50,
requestVolumeThreshold: 10,
resetTimeoutDuration: 30000
})
.baseURL('https://resilient-api.example.com')
.when()
.get('/protected-endpoint')
.execute();
// If the circuit is CLOSED:
// 1. Request attempts normally
// 2. On failure, retry system kicks in (up to 3 attempts)
// 3. Each retry attempt is tracked by circuit breaker
// 4. If overall failure rate exceeds threshold, circuit opens
//
// If the circuit is OPEN:
// 1. Request fails fast immediately (no retry attempts wasted)
// 2. Service gets time to recover
// 3. After timeout, circuit moves to HALF_OPEN for testing
//
// If the circuit is HALF_OPEN:
// 1. Limited requests are allowed through
// 2. Successful requests close the circuit
// 3. Failed requests reopen the circuit
response.statusCode(200);
});
});
`
✅ Automatic Failure Detection: Monitors request success/failure rates automatically
✅ Fast Failure: Prevents wasting resources on failed services
✅ Self-Healing: Automatically tests recovery and resumes normal operation
✅ Configurable Thresholds: Customize failure detection for different service types
✅ Comprehensive Monitoring: Real-time circuit state and performance metrics
✅ Retry Integration: Works seamlessly with retry system for layered resilience
✅ Enterprise Ready: Perfect for microservices, distributed systems, and high availability scenarios
$3
RestifiedTS features advanced timeout intelligence that automatically adapts request timeouts based on endpoint patterns, historical performance data, and request types. No more guessing timeout values or dealing with arbitrary timeouts that are too short or too long.
#### 🎯 1. Intelligent Pattern-Based Timeouts
`typescript
// Automatic timeout assignment based on endpoint patterns
const response = await restified.given()
.timeoutIntelligence({
enabled: true, // Enable intelligent timeouts
patternMatching: true, // Use pattern recognition
adaptiveTimeout: true, // Learn from performance
learningEnabled: true, // Enable performance learning
timeoutMultiplier: 2.5 // Safety multiplier for P95 times
})
.baseURL('https://api.example.com')
.when()
.get('/search?q=products') // Auto-detects search pattern → 20s timeout
.execute();
// Different endpoints get different intelligent timeouts:
// GET /users/123 → 5s (single item retrieval)
// GET /users?page=1 → 10s (list/pagination)
// POST /users → 15s (create operations)
// GET /search → 20s (search operations)
// GET /analytics → 45s (analytics/reports)
// POST /upload → 90s (file upload)
// POST /export → 120s (export/file generation)
`
#### ⚡ 2. Adaptive Learning from Performance
`typescript
// Timeout intelligence learns from actual response times
describe('Adaptive Timeout Learning', () => {
it('should adapt timeouts based on performance history', async () => {
// Reset stats for clean test
restified.resetTimeoutStats();
// Make multiple requests to the same endpoint
for (let i = 0; i < 20; i++) {
await restified.given()
.timeoutIntelligence({
enabled: true,
adaptiveTimeout: true,
learningEnabled: true,
confidenceThreshold: 0.8 // High confidence needed for adaptation
})
.baseURL('https://api.example.com')
.when()
.get('/users')
.execute()
.then(response => response.statusCode(200));
}
// Get learned timeout metrics
const metrics = restified.getTimeoutMetrics('GET:https://api.example.com/users');
console.log(📊 Timeout Intelligence Analytics:);
console.log( Original timeout: ${metrics.stats.averageResponseTime}ms);
console.log( Current timeout: ${metrics.currentTimeout}ms);
console.log( Recommended timeout: ${metrics.recommendedTimeout}ms);
console.log( Confidence level: ${(metrics.confidenceLevel * 100).toFixed(1)}%);
console.log( Performance trend: ${metrics.performanceTrend});
console.log( P95 response time: ${metrics.stats.p95ResponseTime}ms);
console.log( Timeout rate: ${metrics.stats.timeoutRate}%);
});
});
`
#### 🌐 3. Global Timeout Intelligence Configuration
`typescript
// Configure intelligent timeouts globally
const restifiedWithTimeouts = new Restified({
timeoutIntelligence: {
enabled: true,
baseTimeout: 30000, // Fallback timeout
adaptiveTimeout: true, // Enable learning
learningEnabled: true, // Track performance
patternMatching: true, // Use endpoint patterns
minTimeout: 2000, // Minimum allowed timeout
maxTimeout: 300000, // Maximum allowed timeout (5 minutes)
confidenceThreshold: 0.8, // Confidence needed for adaptation
optimizationInterval: 300000, // Auto-optimize every 5 minutes
timeoutMultiplier: 2.5 // P95 * 2.5 = timeout
},
retry: {
enabled: true,
maxAttempts: 3
},
circuitBreaker: {
enabled: true,
failureThreshold: 5
}
});
// All requests now benefit from intelligent timeouts
const [userResponse, searchResponse, analyticsResponse] = await Promise.all([
restifiedWithTimeouts.given().baseURL('https://api.example.com')
.when().get('/users').execute(), // ~5s timeout (single item)
restifiedWithTimeouts.given().baseURL('https://api.example.com')
.when().get('/search?q=term').execute(), // ~20s timeout (search)
restifiedWithTimeouts.given().baseURL('https://api.example.com')
.when().get('/analytics/report').execute() // ~45s timeout (analytics)
]);
`
#### 📊 4. Timeout Analytics and Recommendations
`typescript
// Get intelligent recommendations for timeout optimization
describe('Timeout Intelligence Analytics', () => {
it('should provide actionable timeout recommendations', async () => {
// Simulate various endpoint usage patterns
await simulateEndpointTraffic();
// Get comprehensive timeout statistics
const allStats = restified.getTimeoutStats();
console.log(📈 Monitoring ${allStats.size} endpoints:);
allStats.forEach((stats, endpointId) => {
console.log(\n🔗 Endpoint: ${endpointId});
console.log( Requests: ${stats.totalRequests});
console.log( Avg Response Time: ${stats.averageResponseTime}ms);
console.log( P95 Response Time: ${stats.p95ResponseTime}ms);
console.log( P99 Response Time: ${stats.p99ResponseTime}ms);
console.log( Timeout Rate: ${stats.timeoutRate.toFixed(2)}%);
console.log( Fastest: ${stats.fastestResponseTime}ms);
console.log( Slowest: ${stats.slowestResponseTime}ms);
});
// Get intelligent recommendations
const recommendations = restified.getTimeoutRecommendations();
console.log(\n💡 Timeout Optimization Recommendations:);
recommendations.forEach((rec, index) => {
console.log(\n${index + 1}. ${rec.endpointId});
console.log( Action: ${rec.action.toUpperCase()} timeout);
console.log( Current: ${rec.currentTimeout}ms → Recommended: ${rec.recommendedTimeout}ms);
console.log( Reason: ${rec.reason});
console.log( Confidence: ${(rec.confidence * 100).toFixed(1)}%);
console.log( Impact: ${rec.impact.toUpperCase()});
});
});
async function simulateEndpointTraffic() {
const endpoints = [
{ path: '/users', count: 50 },
{ path: '/users/123', count: 30 },
{ path: '/search?q=test', count: 25 },
{ path: '/analytics/dashboard', count: 15 },
{ path: '/export/csv', count: 10 }
];
for (const endpoint of endpoints) {
for (let i = 0; i < endpoint.count; i++) {
try {
await restified.given()
.timeoutIntelligence({ enabled: true })
.baseURL('https://api.example.com')
.when()
.get(endpoint.path)
.execute();
} catch (error) {
// Continue simulation even with errors
}
}
}
}
});
`
#### 🏭 5. Enterprise Endpoint Pattern Customization
`typescript
// Add custom patterns for specialized business endpoints
describe('Custom Timeout Patterns', () => {
it('should support custom enterprise patterns', async () => {
// Add custom patterns for your business domain
restified.addTimeoutPattern({
name: 'machine-learning',
pattern: /\/ml\/|\/ai\/|\/predict/i,
methods: ['POST'],
baseTimeout: 45000,
multiplier: 3.0,
description: 'ML inference endpoints need more time'
});
restified.addTimeoutPattern({
name: 'blockchain',
pattern: /\/blockchain\/|\/crypto\/|\/wallet/i,
methods: ['GET', 'POST'],
baseTimeout: 30000,
multiplier: 2.0,
description: 'Blockchain operations can be slow'
});
restified.addTimeoutPattern({
name: 'video-processing',
pattern: /\/video\/process|\/media\/convert/i,
methods: ['POST', 'PUT'],
baseTimeout: 180000, // 3 minutes
multiplier: 4.0,
description: 'Video processing takes significant time'
});
// Test endpoints now automatically get appropriate timeouts
const mlResponse = await restified.given()
.timeoutIntelligence({ enabled: true })
.baseURL('https://ml-api.company.com')
.when()
.post('/ml/predict', { data: 'model input' }) // Gets 45s * 3.0 = 135s timeout
.execute();
const videoResponse = await restified.given()
.timeoutIntelligence({ enabled: true })
.baseURL('https://media-api.company.com')
.when()
.post('/video/process', { file: 'video.mp4' }) // Gets 180s * 4.0 = 720s timeout
.execute();
});
});
`
#### 📈 6. Performance Trend Analysis
`typescript
// Monitor performance trends and timeout effectiveness
describe('Performance Trend Monitoring', () => {
it('should track performance trends over time', async () => {
const endpointId = 'GET:https://api.example.com/users';
// Simulate performance over time
await simulatePerformanceTrend(endpointId);
// Get detailed metrics
const metrics = restified.getTimeoutMetrics(endpointId);
console.log(📈 Performance Analysis for ${endpointId}:);
console.log( Current Timeout: ${metrics.currentTimeout}ms);
console.log( Recommended Timeout: ${metrics.recommendedTimeout}ms);
console.log( Adaptive Multiplier: ${metrics.adaptiveMultiplier.toFixed(2)}x);
console.log( Confidence Level: ${(metrics.confidenceLevel * 100).toFixed(1)}%);
console.log( Performance Trend: ${metrics.performanceTrend.toUpperCase()});
console.log( Optimization Count: ${metrics.optimizationCount});
// Apply recommendations if confidence is high
if (metrics.confidenceLevel > 0.8) {
console.log(✅ High confidence - applying recommended timeout);
restified.setTimeoutForEndpoint('GET', '/users', metrics.recommendedTimeout);
} else {
console.log(⚠️ Low confidence - keeping current timeout);
}
// Verify current timeout
const currentTimeout = restified.getCurrentTimeout('GET', '/users');
console.log(🔧 Active timeout: ${currentTimeout}ms);
});
async function simulatePerformanceTrend(endpointId: string) {
// Simulate degrading then improving performance
const phases = [
{ duration: 10, baseTime: 200 }, // Fast phase
{ duration: 15, baseTime: 800 }, // Slow phase
{ duration: 20, baseTime: 300 } // Recovery phase
];
for (const phase of phases) {
for (let i = 0; i < phase.duration; i++) {
const responseTime = phase.baseTime + (Math.random() * 200);
restified.getTimeoutManager().recordResponseTime('GET', '/users', responseTime, false);
}
}
}
});
`
#### 🏥 7. Integration with Circuit Breaker and Retry
`typescript
// Timeout intelligence works seamlessly with other resilience patterns
describe('Integrated Resilience Stack', () => {
it('should provide layered timeout protection', async () => {
const response = await restified.given()
.timeoutIntelligence({
enabled: true,
adaptiveTimeout: true,
patternMatching: true
})
.retry({
enabled: true,
maxAttempts: 3,
baseDelay: 1000
})
.circuitBreaker({
enabled: true,
failureThreshold: 5,
requestVolumeThreshold: 10
})
.baseURL('https://resilient-api.example.com')
.when()
.get('/protected-endpoint')
.execute();
// Layered protection:
// 1. Intelligent Timeout: Automatically sets optimal timeout based on endpoint pattern
// 2. Retry System: Retries failed requests with exponential backoff
// 3. Circuit Breaker: Prevents cascade failures when service is down
// 4. Connection Pool: Reuses connections for performance
response.statusCode(200);
});
});
`
✅ Pattern Recognition: 12+ built-in endpoint patterns (CRUD, search, analytics, uploads, etc.)
✅ Adaptive Learning: Learns from response times and optimizes timeouts automatically
✅ Performance Tracking: P50, P95, P99 response time analysis with trend detection
✅ Confidence-Based: Only applies learned timeouts when confidence threshold is met
✅ Timeout Recommendations: Provides actionable insights for timeout optimization
✅ Custom Patterns: Add business-specific endpoint patterns for specialized timeouts
✅ Global Configuration: Set intelligent defaults for entire application
✅ Integration Ready: Works seamlessly with retry system and circuit breaker
$3
RestifiedTS includes advanced connection pooling with HTTP/2 support for enterprise-grade performance and efficiency. Achieve 20-40% faster request times through intelligent connection reuse.
#### 🔗 1. Basic Connection Pooling
`typescript
// Enable connection pooling for performance
const response = await restified.given()
.connectionPool({
keepAlive: true, // Reuse connections (default: true)
maxSockets: 50, // Max concurrent connections (default: 50)
maxFreeSockets: 10, // Max idle connections to keep (default: 10)
http2: true, // Enable HTTP/2 where supported (default: true)
timeout: 30000 // Connection timeout (default: 30000ms)
})
.baseURL('https://api.example.com')
.when()
.get('/users')
.execute();
response.statusCode(200);
`
#### ⚡ 2. High-Performance Configuration
`typescript
// Optimized for high-throughput APIs
await restified.given()
.connectionPool({
keepAlive: true,
maxSockets: 100, // Higher concurrency
maxFreeSockets: 20, // More idle connections
http2: true, // HTTP/2 multiplexing
keepAliveMsecs: 60000, // Keep connections alive for 60s
noDelay: true, // TCP_NODELAY for lower latency
keepAliveInitialDelay: 1000 // Probe delay
})
.baseURL('https://api.high-performance.com')
.when()
.get('/data')
.execute();
`
#### 🌐 3. Microservices Architecture
``typescript