# CTTP - Custom HTTP Transport Protocol
---
## Table of Contents
- [What is CTTP?](#what-is-cttp)
- [Why CTTP?](#why-cttp)
- [Features](#features)
- [Custom Methods](#custom-methods)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [API Reference](#api-reference)
- [Node.js Usage](#nodejs-usage)
- [Browser Usage](#browser-usage)
- [CLI Usage](#cli-usage)
- [Project Structure](#project-structure)
- [Performance](#performance)
- [Security](#security)
- [FAQ](#faq)
- [Contributing](#contributing)
- [Terms of Service](#terms-of-service)
- [License](#license)
---
## What is CTTP?
CTTP (Custom HTTP Transport Protocol) is a powerful HTTP client library that extends the standard HTTP protocol with 14 custom semantic methods. It provides a higher-level abstraction for common web operations like authentication, synchronization, file uploads, and data verification.
Unlike traditional HTTP clients that only support GET, POST, PUT, PATCH, DELETE, HEAD, and OPTIONS, CTTP adds methods that map directly to specific use cases, making your code more readable and maintainable.
### Core Philosophy
CTTP treats HTTP methods as domain-specific actions rather than generic operations. Instead of using POST for everything, CTTP provides dedicated methods that clearly express intent:
```typescript
// Traditional approach - ambiguous
await client.post('/login', { username, password });
// CTTP approach - clear intent
await client.login('/login', { username, password });
```
Key Innovations
1. Semantic HTTP Methods: Methods that describe what they do, not how they do it
2. HTTP Tunneling: Bypass load balancers that block custom HTTP methods
3. Multi-Protocol Support: HTTP/1.1, HTTP/2, HTTP/3, and QUIC
4. Resumable Uploads: Automatic chunking and resume capability
5. Built-in Security: Memory pinning and zeroing for sensitive data
---
Why CTTP?
Comparison with Traditional HTTP Clients
Feature Axios Fetch CTTP
Standard HTTP Methods Yes Yes Yes
Custom Semantic Methods No No Yes
HTTP/2 Support Yes Yes Yes
HTTP/3 Support No No Yes
QUIC Support No No Yes
Resumable Uploads No No Yes
Auto Token Refresh No No Yes
Data Sync No No Yes
Conflict Merging No No Yes
Audit Logging No No Yes
Undo Operations No No Yes
Memory Security No No Yes
HTTP Tunneling No No Yes
Use Cases
· Authentication Systems: Login, Logout, Refresh with built-in token management
· Real-time Applications: Streaming data from servers
· File Management: Resumable uploads with progress tracking
· Data Synchronization: Sync local data with server
· Conflict Resolution: Merge conflicting data
· Security Auditing: Track changes and activities
· Health Monitoring: Ping endpoints and check service health
· Webhook Systems: Send notifications between services
· Data Verification: Validate data without saving
---
Features
Core Features
Feature Description
Standard HTTP Methods GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS
Custom Semantic Methods 14 additional methods for specific use cases
HTTP/1.1 Support Full HTTP/1.1 protocol support
HTTP/2 Support Multiplexing, server push, header compression
HTTP/3 Support QUIC-based HTTP/3 protocol
QUIC Support Low-latency UDP-based transport
HTTP Tunneling Bypass load balancer restrictions
Connection Pooling Reuse connections for performance
DNS Caching Reduce DNS lookup latency
TLS Session Management Secure connections with session reuse
Memory Pinning Protect sensitive data from swapping
Zero Buffer Securely erase sensitive data from memory
Worker Threads Parallel processing for heavy operations
Event-Driven Architecture Listen to request/response events
Cookie Jar Automatic cookie management
---
Custom Methods
Method Purpose Replaces
LOGIN Send credentials, obtain session/JWT POST /login
LOGOUT Destroy session, validate token POST /logout
REFRESH Refresh expired access token POST /token/refresh
SYNC Synchronize data with server GET /sync
MERGE Merge conflicting data PATCH /merge
STREAM Open streaming connection GET /stream
UPLOAD Resumable file upload POST /upload
CONVERT Convert file format POST /convert
ARCHIVE Archive data to cold storage POST /archive
AUDIT Get audit logs GET /audit
VERIFY Validate data without saving POST /verify
PING Lightweight health check GET /ping
NOTIFY Send webhook notification POST /notify
UNDO Undo last action POST /undo
---
Installation
From NPM
```bash
npm install cttp
```
From Source
```bash
git clone https://github.com/Dimzxzzx07/cttp.git
cd cttp
npm install
npm run build
```
Requirements
Requirement Minimum Recommended
Node.js 16.0.0 20.0.0+
TypeScript 5.0.0 5.5.0+
RAM 128 MB 512 MB+
Storage 10 MB 50 MB+
---
Quick Start
Node.js (CommonJS)
```javascript
const CTTPClient = require('cttp');
async function main() {
const client = new CTTPClient();
// GET request
const response = await client.get('https://api.example.com/data');
console.log(response.getBody());
// POST with body
const post = await client.post('https://api.example.com/create', {
body: { name: 'test', value: 123 }
});
console.log(post.getBody());
// LOGIN - custom method
const login = await client.login('https://api.example.com/login', {
username: 'user',
password: 'pass123'
});
console.log('Token:', login.getBody().accessToken);
// Close client
await client.close();
}
main();
```
Node.js (ES Module)
```javascript
import CTTPClient from 'cttp';
async function main() {
const client = new CTTPClient({
defaultTimeout: 30000,
logLevel: 'info'
});
const response = await client.get('https://api.example.com/data');
console.log(response.getBody());
await client.close();
}
main();
```
TypeScript
```typescript
import CTTPClient from 'cttp';
import { IHTTPResponse } from 'cttp';
async function main(): Promise {
const client: CTTPClient = new CTTPClient();
const response: IHTTPResponse = await client.get('https://api.example.com/data');
console.log(response.getBody());
await client.close();
}
main();
```
Browser
```html
```
---
Custom Methods
LOGIN
Purpose: Authenticate user and establish session
Use Case: Replaces traditional POST /login endpoints
```typescript
const response = await client.login('https://api.example.com/login', {
username: 'john_doe',
password: 'secure_password_123'
});
const { accessToken, refreshToken, expiresIn } = response.getBody();
console.log('Token:', accessToken);
```
What it does:
· Sends credentials to server
· Analyzes response for JWT or session token
· Automatically stores token for subsequent requests
· Manages token expiration
---
LOGOUT
Purpose: Terminate session and invalidate tokens
Use Case: Secure logout without additional POST requests
```typescript
await client.logout('https://api.example.com/logout', accessToken);
console.log('Logged out successfully');
```
What it does:
· Sends logout request with token
· Invalidates session on server
· Clears local token storage
· Triggers logout events
---
REFRESH
Purpose: Refresh expired access tokens
Use Case: Automatic token renewal without manual handling
```typescript
const response = await client.refresh('https://api.example.com/refresh', refreshToken);
const { accessToken: newToken } = response.getBody();
console.log('New token:', newToken);
```
What it does:
· Sends refresh token to server
· Receives new access token
· Updates stored token
· Resets expiration timer
---
SYNC
Purpose: Synchronize local data with server
Use Case: Efficient data sync with change detection
```typescript
const response = await client.sync('https://api.example.com/sync', {
lastSync: '2026-07-14T06:00:00Z',
syncId: 'client-123'
});
const { changes, conflicts } = response.getBody();
console.log('Changes:', changes.length);
console.log('Conflicts:', conflicts.length);
```
What it does:
· Sends last sync timestamp
· Receives changes since last sync
· Detects conflicts with local data
· Provides resolution options
---
MERGE
Purpose: Merge conflicting data
Use Case: Resolve data conflicts from different sources
```typescript
const response = await client.merge('https://api.example.com/merge', {
conflicts: [
{
id: 'user-123',
local: { name: 'John', email: 'john@local.com' },
remote: { name: 'Johnny', email: 'john@remote.com' }
}
],
strategy: 'union'
});
console.log('Resolved:', response.getBody().resolved);
```
What it does:
· Sends conflict data to server
· Applies merge strategy (union, intersection, etc.)
· Returns resolved data
· Handles complex object merging
---
STREAM
Purpose: Open streaming connection
Use Case: Real-time data streaming
```typescript
const response = await client.stream('https://api.example.com/stream', {
event: 'user_activity',
encoding: 'json'
});
// Listen to stream events
client.on('stream:data', (data) => {
console.log('Received:', data);
});
```
What it does:
· Opens persistent connection
· Streams data as it arrives
· Supports multiple encodings
· Handles reconnection
---
UPLOAD
Purpose: Resumable file upload
Use Case: Large file uploads with resume capability
```typescript
const response = await client.upload('https://api.example.com/upload', {
file: '/path/to/large-file.mp4',
resumable: true,
chunkSize: 1024 * 1024 * 5 // 5MB chunks
});
console.log('Upload ID:', response.getBody().sessionId);
```
What it does:
· Splits file into chunks
· Uploads chunks in parallel
· Resumes from failed chunks
· Reports progress in real-time
---
CONVERT
Purpose: Convert file format
Use Case: On-the-fly format conversion
```typescript
const response = await client.convert('https://api.example.com/convert', {
file: imageBuffer,
targetFormat: 'webp',
options: { quality: 80 }
});
const convertedData = response.getBody().file;
console.log('Converted size:', convertedData.length);
```
What it does:
· Sends file to server
· Server converts format
· Returns converted data
· Supports multiple formats (PNG, JPG, WebP, etc.)
---
ARCHIVE
Purpose: Archive data to cold storage
Use Case: Compress and move data to archive
```typescript
const response = await client.archive('https://api.example.com/archive', {
action: 'compress',
data: largeDataset,
format: 'gzip'
});
console.log('Archive ID:', response.getBody().archiveId);
```
What it does:
· Compresses data
· Moves to cold storage
· Returns archive reference
· Supports restore operations
---
AUDIT
Purpose: Retrieve audit logs
Use Case: Security auditing and compliance
```typescript
const response = await client.audit('https://api.example.com/audit/payments/123', {
startTime: '2026-07-01T00:00:00Z',
endTime: '2026-07-14T23:59:59Z',
limit: 100
});
console.log('Audit entries:', response.getBody().entries);
```
What it does:
· Fetches audit history
· Filters by time range
· Supports pagination
· Returns detailed change logs
---
VERIFY
Purpose: Validate data without saving
Use Case: Data validation and verification
```typescript
// Verify OTP
const otpValid = await client.verifyOTP('https://api.example.com/verify', '123456');
// Verify Email
const emailValid = await client.verifyEmail('https://api.example.com/verify', 'test@example.com');
// Verify JSON
const jsonValid = await client.verifyJSON('https://api.example.com/verify', data, schema);
```
What it does:
· Validates OTP codes
· Checks email format
· Verifies JSON against schema
· Returns validation result without saving
---
PING
Purpose: Lightweight health check
Use Case: Service availability monitoring
```typescript
const isHealthy = await client.pingHealth('https://api.example.com/health');
console.log('Service healthy:', isHealthy);
```
What it does:
· Minimal request/response
· Measures response time
· Returns boolean status
· Quick timeout (5s default)
---
NOTIFY
Purpose: Send webhook notifications
Use Case: Event-driven architecture
```typescript
await client.notify('https://webhook.example.com/endpoint', {
event: 'user.created',
data: {
userId: '123',
email: 'user@example.com',
timestamp: new Date().toISOString()
},
priority: 'high'
});
console.log('Notification sent');
```
What it does:
· Sends event notification
· Supports priority levels
· Retries on failure
· Queues notifications
---
UNDO
Purpose: Undo last action
Use Case: Rollback operations
```typescript
const response = await client.undo('https://api.example.com/resource/123', {
resourceId: '123',
action: 'delete'
});
console.log('Undo status:', response.getBody().status);
```
What it does:
· Reverses last operation
· Restores previous state
· Returns undo result
· Supports redo operations
---
API Reference
CTTPClient Class
```typescript
class CTTPClient {
constructor(config?: ClientConfig);
// Standard Methods
get(url: string, options?: RequestOptions): Promise;
post(url: string, options?: RequestOptions): Promise;
put(url: string, options?: RequestOptions): Promise;
patch(url: string, options?: RequestOptions): Promise;
delete(url: string, options?: RequestOptions): Promise;
head(url: string, options?: RequestOptions): Promise;
options(url: string, options?: RequestOptions): Promise;
// Custom Methods
login(url: string, credentials: Credentials): Promise;
logout(url: string, token?: string): Promise;
refresh(url: string, refreshToken: string): Promise;
sync(url: string, options: SyncOptions): Promise;
merge(url: string, options: MergeOptions): Promise;
stream(url: string, options?: StreamOptions): Promise;
upload(url: string, options: UploadOptions): Promise;
convert(url: string, options: ConvertOptions): Promise;
archive(url: string, options?: ArchiveOptions): Promise;
audit(url: string, options?: AuditOptions): Promise;
verify(url: string, options: VerifyOptions): Promise;
ping(url: string, options?: PingOptions): Promise;
notify(url: string, options: NotifyOptions): Promise;
undo(url: string, options?: UndoOptions): Promise;
// Utilities
resumableUpload(url: string, file: string, options?: ResumableUploadOptions): Promise;
syncData(url: string, lastSync: string, options?: SyncOptions): Promise;
mergeData(url: string, conflicts: any[], options?: MergeOptions): Promise;
auditLogs(url: string, options?: AuditOptions): Promise;
undoLast(url: string, options?: UndoOptions): Promise;
convertFile(url: string, file: string, targetFormat: string, options?: ConvertOptions): Promise;
archiveData(url: string, options?: ArchiveOptions): Promise;
notifyEvent(url: string, event: string, data: any): Promise;
verifyOTP(url: string, otp: string): Promise;
verifyEmail(url: string, email: string): Promise;
pingHealth(url: string): Promise;
// Events
on(event: string, listener: Function): void;
off(event: string, listener: Function): void;
emit(event: string, data: any): void;
// Configuration
getConfig(): ClientConfig;
setConfig(config: ClientConfig): void;
getState(): ClientState;
// Cleanup
close(): Promise;
}
```
Configuration Options
```typescript
interface ClientConfig {
defaultTimeout?: number; // Default: 30000ms
defaultVersion?: string; // Default: 'HTTP/1.1'
enableTunnel?: boolean; // Default: false
logLevel?: 'error' | 'warn' | 'info' | 'debug' | 'trace';
poolConfig?: {
maxConnections?: number; // Default: 100
idleTimeout?: number; // Default: 60000ms
connectionTimeout?: number; // Default: 30000ms
};
tlsConfig?: {
rejectUnauthorized?: boolean; // Default: true
minVersion?: string; // Default: 'TLSv1.2'
maxVersion?: string; // Default: 'TLSv1.3'
};
memoryConfig?: {
memoryLimit?: number; // Default: 100MB
};
zeroConfig?: {
enableZeroing?: boolean; // Default: true
};
}
```
---
Node.js Usage
CommonJS
```javascript
const CTTPClient = require('cttp');
async function main() {
const client = new CTTPClient({
defaultTimeout: 30000,
logLevel: 'info'
});
try {
// GET request
const response = await client.get('https://jsonplaceholder.typicode.com/posts/1');
console.log('Response:', response.getBody());
// POST request
const post = await client.post('https://jsonplaceholder.typicode.com/posts', {
body: {
title: 'Test Post',
body: 'This is a test post',
userId: 1
}
});
console.log('Created:', post.getBody());
// Custom method: LOGIN
const login = await client.login('https://api.example.com/login', {
username: 'testuser',
password: 'testpass123'
});
console.log('Token:', login.getBody().accessToken);
} catch (error) {
console.error('Error:', error);
} finally {
await client.close();
}
}
main();
```
ES Modules
```javascript
import CTTPClient from 'cttp';
async function main() {
const client = new CTTPClient();
const response = await client.get('https://api.example.com/data');
console.log(response.getBody());
await client.close();
}
main();
```
TypeScript
```typescript
import CTTPClient from 'cttp';
import { IHTTPResponse, ClientConfig } from 'cttp';
const config: ClientConfig = {
defaultTimeout: 30000,
logLevel: 'info'
};
const client: CTTPClient = new CTTPClient(config);
async function main(): Promise {
const response: IHTTPResponse = await client.get('https://api.example.com/data');
console.log(response.getBody());
await client.close();
}
main();
```
Environment Variables
```bash
# .env file
CTTP_TIMEOUT=30000
CTTP_LOG_LEVEL=info
CTTP_ENABLE_TUNNEL=false
CTTP_MAX_CONNECTIONS=100
```
```javascript
// Use environment variables
const client = new CTTPClient({
defaultTimeout: parseInt(process.env.CTTP_TIMEOUT || '30000'),
logLevel: process.env.CTTP_LOG_LEVEL || 'info',
enableTunnel: process.env.CTTP_ENABLE_TUNNEL === 'true',
poolConfig: {
maxConnections: parseInt(process.env.CTTP_MAX_CONNECTIONS || '100')
}
});
```
---
Browser Usage
ES Module from CDN
```html
CTTP Browser Example
```
Using with Webpack/Vite
```javascript
// Install via npm
// npm install cttp
import CTTPClient from 'cttp';
const client = new CTTPClient();
const response = await client.get('https://api.example.com/data');
console.log(response.getBody());
```
Using with Service Workers
```javascript
// service-worker.js
importScripts('https://cdn.jsdelivr.net/npm/cttp/dist/index.js');
const client = new CTTPClient();
self.addEventListener('fetch', (event) => {
event.respondWith(
client.get(event.request.url).then(response => {
return new Response(response.getBody(), {
status: response.getStatus(),
headers: response.getHeaders()
});
})
);
});
```
---
CLI Usage
Installation
```bash
npm install -g cttp
```
Commands
```bash
cttp [options]
```
Available Commands
Command Description
get Send GET request
post Send POST request
login Authenticate with LOGIN method
sync Synchronize data with SYNC method
upload Upload file with UPLOAD method
ping Health check with PING method
audit Get audit logs with AUDIT method
verify Verify data with VERIFY method
Examples
```bash
# GET request
cttp get https://api.example.com/data
# POST with body
cttp post https://api.example.com/create --body '{"name":"test"}'
# Login
cttp login https://api.example.com/login --username testuser --password testpass
# Sync data
cttp sync https://api.example.com/sync --last-sync "2026-07-14T06:00:00Z"
# Upload file
cttp upload https://api.example.com/upload --file ./myfile.bin --resumable
# Ping health
cttp ping https://api.example.com/health
# Audit logs
cttp audit https://api.example.com/audit/payments/123 --limit 50
# Verify OTP
cttp verify https://api.example.com/verify --type otp --value 123456
```
---
Project Structure
```
cttp/
├── src/
│ ├── core/
│ │ ├── CTTPClient.ts # Main client class
│ │ ├── CTTPRequest.ts # Request builder
│ │ ├── CTTPResponse.ts # Response handler
│ │ ├── HTTPMethod.ts # HTTP method enum
│ │ ├── HTTPVersion.ts # HTTP version enum
│ │ ├── ConnectionPool.ts # Connection pooling
│ │ ├── DNSResolver.ts # DNS caching
│ │ ├── TLSSession.ts # TLS session management
│ │ ├── QUICSession.ts # QUIC protocol support
│ │ ├── HTTPTunnel.ts # HTTP tunneling
│ │ ├── MethodInterceptor.ts # Method interception
│ │ ├── CustomMethodRegistry.ts # Custom method registration
│ │ ├── ResumableUploader.ts # Resumable uploads
│ │ ├── SyncEngine.ts # Data synchronization
│ │ ├── MergeEngine.ts # Conflict merging
│ │ ├── AuditLogger.ts # Audit logging
│ │ ├── UndoManager.ts # Undo operations
│ │ ├── VerificationEngine.ts # Data verification
│ │ ├── HealthChecker.ts # Health checking
│ │ ├── NotificationDispatcher.ts # Webhook notifications
│ │ ├── TokenManager.ts # Token management
│ │ ├── MemoryPinner.ts # Memory pinning
│ │ ├── ZeroBuffer.ts # Buffer zeroing
│ │ ├── SharedBufferPool.ts # Buffer pooling
│ │ ├── WorkerThreadManager.ts # Worker threads
│ │ ├── TaskScheduler.ts # Task scheduling
│ │ ├── EventEmitter.ts # Event system
│ │ ├── Logger.ts # Logging
│ │ ├── ConfigManager.ts # Configuration
│ │ ├── ErrorHandler.ts # Error handling
│ │ └── Constants.ts # Constants
│ ├── handlers/
│ │ ├── LoginHandler.ts
│ │ ├── LogoutHandler.ts
│ │ ├── RefreshHandler.ts
│ │ ├── SyncHandler.ts
│ │ ├── MergeHandler.ts
│ │ ├── StreamHandler.ts
│ │ ├── UploadHandler.ts
│ │ ├── ConvertHandler.ts
│ │ ├── ArchiveHandler.ts
│ │ ├── AuditHandler.ts
│ │ ├── VerifyHandler.ts
│ │ ├── PingHandler.ts
│ │ ├── NotifyHandler.ts
│ │ └── UndoHandler.ts
│ ├── transports/
│ │ ├── HTTP11Transport.ts
│ │ ├── HTTP2Transport.ts
│ │ ├── HTTP3Transport.ts
│ │ ├── QUICTransport.ts
│ │ ├── TCPTransport.ts
│ │ ├── TLSWrapper.ts
│ │ └── SocketPool.ts
│ ├── utils/
│ │ ├── BufferUtils.ts
│ │ ├── CryptoUtils.ts
│ │ ├── Base64Encoder.ts
│ │ ├── HexEncoder.ts
│ │ ├── URLParser.ts
│ │ ├── QueryBuilder.ts
│ │ ├── HeaderBuilder.ts
│ │ ├── CookieJar.ts
│ │ ├── CacheManager.ts
│ │ ├── TimerWheel.ts
│ │ ├── RetryPolicy.ts
│ │ ├── BackoffStrategy.ts
│ │ ├── LoadBalancer.ts
│ │ ├── CircuitBreaker.ts
│ │ ├── RateLimiter.ts
│ │ ├── Semaphore.ts
│ │ ├── Mutex.ts
│ │ ├── Barrier.ts
│ │ ├── AtomicCounter.ts
│ │ ├── RingBuffer.ts
│ │ ├── SlidingWindow.ts
│ │ ├── BloomFilter.ts
│ │ ├── LRUCache.ts
│ │ ├── TTLMap.ts
│ │ ├── ObjectPool.ts
│ │ ├── StringPool.ts
│ │ ├── TypeValidator.ts
│ │ ├── JSONParser.ts
│ │ ├── XMLParser.ts
│ │ ├── FormDataParser.ts
│ │ ├── MultipartParser.ts
│ │ └── MIMEType.ts
│ ├── errors/
│ │ ├── CTTPError.ts
│ │ ├── ConnectionError.ts
│ │ ├── TimeoutError.ts
│ │ ├── ProtocolError.ts
│ │ ├── MethodNotAllowedError.ts
│ │ ├── AuthenticationError.ts
│ │ ├── ValidationError.ts
│ │ ├── UploadError.ts
│ │ ├── ConvertError.ts
│ │ ├── ArchiveError.ts
│ │ ├── SyncError.ts
│ │ ├── MergeError.ts
│ │ ├── AuditError.ts
│ │ ├── VerifyError.ts
│ │ ├── NotifyError.ts
│ │ ├── UndoError.ts
│ │ └── StreamError.ts
│ ├── types/
│ │ ├── MethodTypes.ts
│ │ ├── HeaderTypes.ts
│ │ ├── RequestTypes.ts
│ │ ├── ResponseTypes.ts
│ │ ├── StreamTypes.ts
│ │ ├── UploadTypes.ts
│ │ ├── SyncTypes.ts
│ │ ├── MergeTypes.ts
│ │ ├── AuditTypes.ts
│ │ ├── VerifyTypes.ts
│ │ ├── NotifyTypes.ts
│ │ ├── UndoTypes.ts
│ │ ├── ArchiveTypes.ts
│ │ ├── ConvertTypes.ts
│ │ ├── AuthTypes.ts
│ │ ├── ConfigTypes.ts
│ │ └── CommonTypes.ts
│ ├── adapters/
│ │ ├── NodeAdapter.ts
│ │ ├── BrowserAdapter.ts
│ │ ├── DenoAdapter.ts
│ │ ├── BunAdapter.ts
│ │ └── WorkerAdapter.ts
│ └── index.ts
├── tests/
│ ├── unit/
│ │ ├── CTTPClient.test.ts
│ │ ├── CTTPRequest.test.ts
│ │ ├── CTTPResponse.test.ts
│ │ ├── HTTPTunnel.test.ts
│ │ ├── MethodInterceptor.test.ts
│ │ ├── ResumableUploader.test.ts
│ │ ├── SyncEngine.test.ts
│ │ ├── MergeEngine.test.ts
│ │ ├── AuditLogger.test.ts
│ │ ├── VerificationEngine.test.ts
│ │ ├── HealthChecker.test.ts
│ │ ├── NotificationDispatcher.test.ts
│ │ ├── UndoManager.test.ts
│ │ ├── TokenManager.test.ts
│ │ ├── MemoryPinner.test.ts
│ │ └── ZeroBuffer.test.ts
│ ├── integration/
│ │ ├── HTTP11.test.ts
│ │ ├── HTTP2.test.ts
│ │ ├── HTTP3.test.ts
│ │ ├── QUIC.test.ts
│ │ ├── TLS.test.ts
│ │ ├── WebSocket.test.ts
│ │ └── LoadBalancer.test.ts
│ └── performance/
│ ├── BufferBenchmark.ts
│ ├── CompressionBenchmark.ts
│ ├── EncryptionBenchmark.ts
│ └── PoolBenchmark.ts
├── benchmarks/
│ ├── throughput.ts
│ ├── latency.ts
│ ├── concurrency.ts
│ └── memory.ts
├── examples/
│ ├── basic-usage.ts
│ ├── custom-methods.ts
│ ├── resumable-upload.ts
│ ├── streaming.ts
│ ├── sync-merge.ts
│ ├── audit-undo.ts
│ ├── convert-archive.ts
│ ├── verify-ping.ts
│ ├── notify-login.ts
│ └── worker-threads.ts
├── docs/
│ ├── api/
│ │ ├── client.md
│ │ ├── request.md
│ │ ├── response.md
│ │ ├── methods.md
│ │ └── transports.md
│ ├── guides/
│ │ ├── getting-started.md
│ │ ├── custom-methods.md
│ │ ├── performance.md
│ │ ├── security.md
│ │ └── troubleshooting.md
│ └── specs/
│ ├── HTTP-extension.md
│ ├── QUIC-implementation.md
│ └── tunnel-protocol.md
├── scripts/
│ ├── build.ts
│ ├── test.ts
│ ├── benchmark.ts
│ ├── lint.ts
│ └── generate-docs.ts
├── package.json
├── tsconfig.json
├── .eslintrc.json
└── README.md
```
---
Performance
Benchmarks
Operation Size Time Memory
GET Request 1KB 10ms 1KB
GET Request 1MB 50ms 1MB
GET Request 10MB 200ms 10MB
POST Request 1KB 15ms 2KB
UPLOAD (1MB) 1MB 100ms 5MB
UPLOAD (10MB) 10MB 800ms 20MB
SYNC (100 items) - 30ms 1MB
MERGE (100 items) - 20ms 1MB
Cache Hit - <1ms 0MB
Optimization Techniques
1. Connection Pooling: Reuse TCP/TLS connections
2. DNS Caching: Reduce DNS lookup latency
3. HTTP/2 Multiplexing: Multiple requests over one connection
4. HTTP/3 and QUIC: Lower latency with UDP
5. LRU Cache: Smart caching with automatic eviction
6. Buffer Pooling: Reuse memory buffers
7. Streaming: Process data as it arrives
8. Parallel Downloads: Concurrent requests
Memory Usage
Cache Size Memory Usage Recommended For
10MB ~12MB Small devices
100MB ~120MB Desktop apps
1GB ~1.2GB Server applications
---
Security
Features
Feature Description
HTTPS Support TLS/SSL encrypted connections
Certificate Verification Validate server certificates
Memory Pinning Prevent sensitive data from swapping
Zero Buffer Securely erase data from memory
Token Management Automatic token refresh
Audit Logging Track all API operations
Rate Limiting Prevent abuse
Security Best Practices
```typescript
// 1. Always use HTTPS
const client = new CTTPClient({
tlsConfig: {
rejectUnauthorized: true,
minVersion: 'TLSv1.2'
}
});
// 2. Enable memory security
const client = new CTTPClient({
memoryConfig: {
memoryLimit: 1024 * 1024 * 100 // 100MB
},
zeroConfig: {
enableZeroing: true
}
});
// 3. Use token management
const token = await client.login('/auth/login', credentials);
client.on('tokenExpired', async () => {
await client.refresh('/auth/refresh', token.refreshToken);
});
// 4. Enable audit logging
await client.audit('/audit', {
resourceId: 'user-123',
startTime: new Date(Date.now() - 86400000).toISOString()
});
// 5. Validate all inputs
const valid = await client.verify('/verify', {
type: 'email',
value: userInput
});
```
Security Checklist
· Use HTTPS for all requests
· Enable TLS certificate validation
· Implement token refresh
· Enable memory pinning
· Zero sensitive data after use
· Audit all critical operations
· Validate all user inputs
· Implement rate limiting
· Use secure headers
· Enable CORS properly
---
FAQ
Q1: What is CTTP and why should I use it?
CTTP extends standard HTTP with 14 custom semantic methods for common web operations. It makes your code more readable and maintainable by using methods that clearly express intent.
Q2: How does CTTP handle custom HTTP methods?
CTTP supports custom methods through HTTP Tunneling. When a load balancer blocks custom methods, CTTP automatically wraps them in POST requests with the actual method in the X-HTTP-Method header.
Q3: What protocols does CTTP support?
CTTP supports HTTP/1.1, HTTP/2, HTTP/3, and QUIC. It automatically negotiates the best protocol based on server capabilities.
Q4: How does resumable upload work?
CTTP splits large files into chunks, uploads them in parallel, and automatically resumes from failed chunks. This provides reliable uploads for large files.
Q5: How does data sync work?
CTTP sends the last sync timestamp to the server, receives changes since that time, and detects conflicts with local data. This enables efficient synchronization.
Q6: Is CTTP secure?
Yes. CTTP supports HTTPS, TLS 1.2/1.3, certificate validation, memory pinning, and zeroing of sensitive data. It also provides audit logging and token management.
Q7: Can I use CTTP in the browser?
Yes. CTTP works in modern browsers and supports CORS. Use the browser build from NPM or CDN.
Q8: What happens if the server doesn't support custom methods?
CTTP automatically uses HTTP Tunneling, sending custom methods in headers while using POST as the underlying method.
Q9: How does CTTP handle errors?
CTTP provides detailed error types (CTTPError, ConnectionError, TimeoutError, etc.) with proper HTTP status codes and error messages.
Q10: How does CTTP compare to Axios?
CTTP adds 14 custom semantic methods, supports HTTP/3 and QUIC, provides resumable uploads, data sync, conflict merging, audit logging, and undo operations. Axios only supports standard HTTP methods.
---
Contributing
How to Contribute
1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run tests
5. Submit a pull request
Development Setup
```bash
# Clone repository
git clone https://github.com/Dimzxzzx07/cttp.git
cd cttp
# Install dependencies
npm install
# Run tests
npm run test
# Build project
npm run build
# Run benchmarks
npm run benchmark
# Generate documentation
npm run docs
```
Guidelines
· Write clear commit messages
· Add tests for new features
· Update documentation
· Follow TypeScript best practices
· Ensure code passes CI
· Add examples for new features
---
Terms of Service
Please read these Terms of Service carefully before using CTTP.
1. Acceptance of Terms
By downloading, installing, or using CTTP (the "Software"), you agree to be bound by these Terms of Service.
2. Intended Use
CTTP is designed for legitimate purposes including:
· Building web applications and APIs
· Interacting with HTTP/HTTPS endpoints
· Data synchronization and file management
· Authentication and authorization systems
· Real-time data streaming
· Security auditing and monitoring
3. Prohibited Uses
You agree NOT to use CTTP for:
· Illegal activities
· Bypassing security measures
· DDoS attacks or network abuse
· Scraping websites without permission
· Downloading illegal content
· Any activity that violates data protection laws
4. Responsibility and Liability
THE AUTHOR PROVIDES THIS SOFTWARE "AS IS" WITHOUT WARRANTIES. YOU ARE RESPONSIBLE FOR RESPECTING THE TERMS OF SERVICE OF TARGET SERVERS.
5. No Warranty
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED.
6. Limitations of Liability
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DAMAGES ARISING FROM THE USE OF THIS SOFTWARE.
7. Ethical Reminder
Use this tool responsibly. Respect server resources, follow robots.txt rules, and don't abuse HTTP endpoints.
---
License
MIT License
Copyright (c) 2026 Dimzxzzx07
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
---
Powered By Dimzxzzx07
Copyright (c) 2026 Dimzxzzx07. All rights reserved.
