rdapify 0.2.3 → 0.3.1

package/dist/esm/application/services/BatchProcessor.js

@@ -0,0 +1,145 @@
+export class BatchProcessor {
+    constructor(client) {
+        this.client = client;
+    }
+    async processBatch(requests, options = {}) {
+        const { concurrency = 5, continueOnError = true, } = options;
+        const results = [];
+        const queue = [...requests];
+        const inProgress = [];
+        const processOne = async (request) => {
+            const startTime = Date.now();
+            try {
+                let result;
+                switch (request.type) {
+                    case 'domain':
+                        result = await this.client.domain(request.query);
+                        break;
+                    case 'ip':
+                        result = await this.client.ip(request.query);
+                        break;
+                    case 'asn':
+                        result = await this.client.asn(request.query);
+                        break;
+                    case 'nameserver':
+                        result = await this.client.nameserver(request.query);
+                        break;
+                    case 'entity':
+                        if (!request.serverUrl) {
+                            throw new Error(`Entity queries require a serverUrl. Set { type: 'entity', query: '${request.query}', serverUrl: 'https://...' }`);
+                        }
+                        result = await this.client.entity(request.query, request.serverUrl);
+                        break;
+                    default:
+                        throw new Error(`Unknown query type: ${request.type}`);
+                }
+                results.push({
+                    type: request.type,
+                    query: request.query,
+                    result,
+                    duration: Date.now() - startTime,
+                });
+            }
+            catch (error) {
+                results.push({
+                    type: request.type,
+                    query: request.query,
+                    error: error,
+                    duration: Date.now() - startTime,
+                });
+                if (!continueOnError) {
+                    throw error;
+                }
+            }
+        };
+        while (queue.length > 0 || inProgress.length > 0) {
+            while (inProgress.length < concurrency && queue.length > 0) {
+                const request = queue.shift();
+                const promise = processOne(request);
+                inProgress.push(promise);
+                const cleanup = () => {
+                    const index = inProgress.indexOf(promise);
+                    if (index > -1) {
+                        inProgress.splice(index, 1);
+                    }
+                };
+                promise.then(cleanup, cleanup);
+            }
+            if (inProgress.length > 0) {
+                await Promise.race(inProgress);
+            }
+        }
+        return results;
+    }
+    async processBatchWithTimeout(requests, timeoutMs, options = {}) {
+        return Promise.race([
+            this.processBatch(requests, options),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Batch processing timeout after ${timeoutMs}ms`)), timeoutMs)),
+        ]);
+    }
+    async executeOne(request) {
+        switch (request.type) {
+            case 'domain':
+                return this.client.domain(request.query);
+            case 'ip':
+                return this.client.ip(request.query);
+            case 'asn':
+                return this.client.asn(request.query);
+            case 'nameserver':
+                return this.client.nameserver(request.query);
+            case 'entity':
+                if (!request.serverUrl) {
+                    throw new Error(`Entity queries require a serverUrl. Set { type: 'entity', query: '${request.query}', serverUrl: 'https://...' }`);
+                }
+                return this.client.entity(request.query, request.serverUrl);
+            default:
+                throw new Error(`Unknown query type: ${request.type}`);
+        }
+    }
+    async *streamBatch(requests, options = {}) {
+        const { concurrency = 5, continueOnError = true } = options;
+        const queue = [...requests];
+        while (queue.length > 0) {
+            const chunk = queue.splice(0, concurrency);
+            const results = await Promise.all(chunk.map(async (request) => {
+                const t0 = Date.now();
+                try {
+                    const result = await this.executeOne(request);
+                    return {
+                        type: request.type,
+                        query: request.query,
+                        result,
+                        duration: Date.now() - t0,
+                    };
+                }
+                catch (error) {
+                    if (!continueOnError)
+                        throw error;
+                    return {
+                        type: request.type,
+                        query: request.query,
+                        error: error,
+                        duration: Date.now() - t0,
+                    };
+                }
+            }));
+            for (const result of results) {
+                yield result;
+            }
+        }
+    }
+    analyzeBatchResults(results) {
+        const successful = results.filter((r) => !r.error).length;
+        const failed = results.filter((r) => r.error).length;
+        const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+        const averageDuration = results.length > 0 ? totalDuration / results.length : 0;
+        return {
+            total: results.length,
+            successful,
+            failed,
+            averageDuration,
+            totalDuration,
+            successRate: results.length > 0 ? (successful / results.length) * 100 : 0,
+        };
+    }
+}