@push.rocks/smartrequest
Version:
A module for modern HTTP/HTTPS requests with support for form data, file uploads, JSON, binary data, streams, and more.
362 lines • 22.5 kB
JavaScript
import { CoreRequest, CoreResponse } from '../core/index.js';
import * as plugins from './plugins.js';
import { PaginationStrategy } from './types/pagination.js';
import { createPaginatedResponse } from './features/pagination.js';
/**
* Parse Retry-After header value to milliseconds
* @param retryAfter - The Retry-After header value (seconds or HTTP date)
* @returns Delay in milliseconds
*/
function parseRetryAfter(retryAfter) {
// Handle array of values (take first)
const value = Array.isArray(retryAfter) ? retryAfter[0] : retryAfter;
if (!value)
return 0;
// Try to parse as seconds (number)
const seconds = parseInt(value, 10);
if (!isNaN(seconds)) {
return seconds * 1000;
}
// Try to parse as HTTP date
const retryDate = new Date(value);
if (!isNaN(retryDate.getTime())) {
return Math.max(0, retryDate.getTime() - Date.now());
}
return 0;
}
/**
* Modern fluent client for making HTTP requests
*/
export class SmartRequest {
constructor() {
this._options = {};
this._retries = 0;
this._queryParams = {};
}
/**
* Create a new SmartRequest instance
*/
static create() {
return new SmartRequest();
}
/**
* Set the URL for the request
*/
url(url) {
this._url = url;
return this;
}
/**
* Set the HTTP method
*/
method(method) {
this._options.method = method;
return this;
}
/**
* Set JSON body for the request
*/
json(data) {
if (!this._options.headers) {
this._options.headers = {};
}
this._options.headers['Content-Type'] = 'application/json';
this._options.requestBody = data;
return this;
}
/**
* Set form data for the request
*/
formData(data) {
const form = new plugins.formData();
for (const item of data) {
if (Buffer.isBuffer(item.value)) {
form.append(item.name, item.value, {
filename: item.filename || 'file',
contentType: item.contentType || 'application/octet-stream'
});
}
else {
form.append(item.name, item.value);
}
}
if (!this._options.headers) {
this._options.headers = {};
}
this._options.headers = {
...this._options.headers,
...form.getHeaders()
};
this._options.requestBody = form;
return this;
}
/**
* Set request timeout in milliseconds
*/
timeout(ms) {
this._options.timeout = ms;
this._options.hardDataCuttingTimeout = ms;
return this;
}
/**
* Set number of retry attempts
*/
retry(count) {
this._retries = count;
return this;
}
/**
* Enable automatic 429 (Too Many Requests) handling with configurable backoff
*/
handle429Backoff(config) {
this._rateLimitConfig = {
maxRetries: config?.maxRetries ?? 3,
respectRetryAfter: config?.respectRetryAfter ?? true,
maxWaitTime: config?.maxWaitTime ?? 60000,
fallbackDelay: config?.fallbackDelay ?? 1000,
backoffFactor: config?.backoffFactor ?? 2,
onRateLimit: config?.onRateLimit
};
return this;
}
/**
* Set HTTP headers
*/
headers(headers) {
if (!this._options.headers) {
this._options.headers = {};
}
this._options.headers = {
...this._options.headers,
...headers
};
return this;
}
/**
* Set a single HTTP header
*/
header(name, value) {
if (!this._options.headers) {
this._options.headers = {};
}
this._options.headers[name] = value;
return this;
}
/**
* Set query parameters
*/
query(params) {
this._queryParams = {
...this._queryParams,
...params
};
return this;
}
/**
* Set additional request options
*/
options(options) {
this._options = {
...this._options,
...options
};
return this;
}
/**
* Enable or disable auto-drain for unconsumed response bodies (Node.js only)
* Default is true to prevent socket hanging
*/
autoDrain(enabled) {
this._options.autoDrain = enabled;
return this;
}
/**
* Set the Accept header to indicate what content type is expected
*/
accept(type) {
// Map response types to Accept header values
const acceptHeaders = {
'json': 'application/json',
'text': 'text/plain',
'binary': 'application/octet-stream',
'stream': '*/*'
};
return this.header('Accept', acceptHeaders[type]);
}
/**
* Configure pagination for requests
*/
pagination(config) {
this._paginationConfig = config;
return this;
}
/**
* Configure offset-based pagination (page & limit)
*/
withOffsetPagination(config = {}) {
this._paginationConfig = {
strategy: PaginationStrategy.OFFSET,
pageParam: config.pageParam || 'page',
limitParam: config.limitParam || 'limit',
startPage: config.startPage || 1,
pageSize: config.pageSize || 20,
totalPath: config.totalPath || 'total'
};
// Add initial pagination parameters
this.query({
[this._paginationConfig.pageParam]: String(this._paginationConfig.startPage),
[this._paginationConfig.limitParam]: String(this._paginationConfig.pageSize)
});
return this;
}
/**
* Configure cursor-based pagination
*/
withCursorPagination(config = {}) {
this._paginationConfig = {
strategy: PaginationStrategy.CURSOR,
cursorParam: config.cursorParam || 'cursor',
cursorPath: config.cursorPath || 'nextCursor',
hasMorePath: config.hasMorePath || 'hasMore'
};
return this;
}
/**
* Configure Link header-based pagination
*/
withLinkPagination() {
this._paginationConfig = {
strategy: PaginationStrategy.LINK_HEADER
};
return this;
}
/**
* Configure custom pagination
*/
withCustomPagination(config) {
this._paginationConfig = {
strategy: PaginationStrategy.CUSTOM,
hasNextPage: config.hasNextPage,
getNextPageParams: config.getNextPageParams
};
return this;
}
/**
* Make a GET request
*/
async get() {
return this.execute('GET');
}
/**
* Make a POST request
*/
async post() {
return this.execute('POST');
}
/**
* Make a PUT request
*/
async put() {
return this.execute('PUT');
}
/**
* Make a DELETE request
*/
async delete() {
return this.execute('DELETE');
}
/**
* Make a PATCH request
*/
async patch() {
return this.execute('PATCH');
}
/**
* Get paginated response
*/
async getPaginated() {
if (!this._paginationConfig) {
throw new Error('Pagination not configured. Call one of the pagination methods first.');
}
// Default to GET if no method specified
if (!this._options.method) {
this._options.method = 'GET';
}
const response = await this.execute();
return await createPaginatedResponse(response, this._paginationConfig, this._queryParams, (nextPageParams) => {
// Create a new client with the same configuration but updated query params
const nextClient = new SmartRequest();
Object.assign(nextClient, this);
nextClient._queryParams = nextPageParams;
return nextClient.getPaginated();
});
}
/**
* Get all pages at once (use with caution for large datasets)
*/
async getAllPages() {
const firstPage = await this.getPaginated();
return firstPage.getAllPages();
}
/**
* Execute the HTTP request
*/
async execute(method) {
if (method) {
this._options.method = method;
}
this._options.queryParams = this._queryParams;
// Track rate limit attempts separately
let rateLimitAttempt = 0;
let lastError;
// Main retry loop
for (let attempt = 0; attempt <= this._retries; attempt++) {
try {
const request = new CoreRequest(this._url, this._options);
const response = await request.fire();
// Check for 429 status if rate limit handling is enabled
if (this._rateLimitConfig && response.status === 429) {
if (rateLimitAttempt >= this._rateLimitConfig.maxRetries) {
// Max rate limit retries reached, return the 429 response
return response;
}
let waitTime;
if (this._rateLimitConfig.respectRetryAfter && response.headers['retry-after']) {
// Parse Retry-After header
waitTime = parseRetryAfter(response.headers['retry-after']);
// Cap wait time to maxWaitTime
waitTime = Math.min(waitTime, this._rateLimitConfig.maxWaitTime);
}
else {
// Use exponential backoff
waitTime = Math.min(this._rateLimitConfig.fallbackDelay * Math.pow(this._rateLimitConfig.backoffFactor, rateLimitAttempt), this._rateLimitConfig.maxWaitTime);
}
// Call rate limit callback if provided
if (this._rateLimitConfig.onRateLimit) {
this._rateLimitConfig.onRateLimit(rateLimitAttempt + 1, waitTime);
}
// Wait before retrying
await new Promise(resolve => setTimeout(resolve, waitTime));
rateLimitAttempt++;
// Decrement attempt to retry this attempt
attempt--;
continue;
}
// Success or non-429 error response
return response;
}
catch (error) {
lastError = error;
// If this is the last attempt, throw the error
if (attempt === this._retries) {
throw lastError;
}
// Otherwise, wait before retrying
await new Promise(resolve => setTimeout(resolve, 1000));
}
}
// This should never be reached due to the throw in the loop above
throw lastError;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartrequest.js","sourceRoot":"","sources":["../../ts/client/smartrequest.ts"],"names":[],"mappings":"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"}