@iota-big3/sdk-gateway
Version:
Universal API Gateway with protocol translation, intelligent routing, rate limiting, health checking, and caching
111 lines • 4.09 kB
JavaScript
;
/**
* @iota-big3/sdk-gateway
* Clean Response Aggregator - Phase 2d Rebuild
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.ResponseAggregator = void 0;
const tslib_1 = require("tslib");
const axios_1 = tslib_1.__importDefault(require("axios"));
const events_1 = require("events");
class ResponseAggregator extends events_1.EventEmitter {
constructor(httpClient) {
super();
this.isEnabled = true;
// Use provided client or create default
this.httpClient = httpClient || axios_1.default.create({
timeout: 30000,
validateStatus: () => true // Handle all status codes
});
}
/**
* Aggregate multiple service requests
*/
async aggregateAsync(request) {
const startTime = Date.now();
const timing = {};
const errors = [];
try {
// Execute requests (parallel by default)
const results = await this.executeParallelAsync(request.requests, timing, errors);
// Check required services
const failedRequired = request.requests
.filter((req, index) => req.required && !results[index])
.map(req => req.service);
if (failedRequired.length > 0) {
throw new Error(`Required services failed: ${failedRequired.join(', ')}`);
}
// Apply aggregation strategy
const aggregatedData = this.applyStrategy(results, request.strategy || 'merge', request.transform);
timing.total = Date.now() - startTime;
this.emit('aggregation:complete', {
requests: request.requests.length,
duration: timing.total,
errors: errors.length
});
return {
success: errors.length === 0,
data: aggregatedData,
errors,
timing
};
}
catch (error) {
timing.total = Date.now() - startTime;
this.emit('aggregation:error', {
error: error instanceof Error ? error.message : 'Unknown error',
duration: timing.total
});
throw error;
}
}
async executeParallelAsync(requests, timing, errors) {
const promises = requests.map(async (req, index) => {
const serviceStart = Date.now();
try {
const response = await this.httpClient.request({
method: req.method || 'GET',
url: `${req.service}${req.path}`,
data: req.body
});
timing[`service_${index}`] = Date.now() - serviceStart;
if (response.status >= 400) {
throw new Error(`HTTP ${response.status}: ${response.statusText}`);
}
return response.data;
}
catch (error) {
timing[`service_${index}`] = Date.now() - serviceStart;
errors.push({
service: req.service,
error: error instanceof Error ? error.message : 'Unknown error'
});
if (req.required) {
throw error;
}
return null;
}
});
return Promise.all(promises);
}
applyStrategy(results, strategy, transform) {
if (transform) {
return transform(results);
}
switch (strategy) {
case 'merge':
return results.reduce((acc, result) => {
if (result && typeof result === 'object') {
return { ...acc, ...result };
}
return acc;
}, {});
case 'concat':
return results.filter(r => r !== null);
default:
return results;
}
}
}
exports.ResponseAggregator = ResponseAggregator;
//# sourceMappingURL=response-aggregator.js.map