@retab/node 0.0.0-reserved → 0.0.43

package/dist/utils/stream_context_managers.js

@@ -0,0 +1,380 @@
+/**
+ * Stream context management utilities for proper resource cleanup
+ * Equivalent to Python's stream_context_managers.py
+ */
+/**
+ * AsyncGenerator context manager for proper cleanup
+ */
+export class AsyncGeneratorContextManager {
+    constructor(generator) {
+        this.isFinalized = false;
+        this.generator = generator;
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            yield* this.generator;
+        }
+        finally {
+            await this.cleanup();
+        }
+    }
+    async next() {
+        try {
+            return await this.generator.next();
+        }
+        catch (error) {
+            await this.cleanup();
+            throw error;
+        }
+    }
+    async return(value) {
+        try {
+            return await this.generator.return(value);
+        }
+        finally {
+            await this.cleanup();
+        }
+    }
+    async throw(error) {
+        try {
+            return await this.generator.throw(error);
+        }
+        finally {
+            await this.cleanup();
+        }
+    }
+    async cleanup() {
+        if (!this.isFinalized) {
+            this.isFinalized = true;
+            try {
+                // Ensure generator is properly closed
+                if (typeof this.generator.return === 'function') {
+                    await this.generator.return();
+                }
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        await this.cleanup();
+    }
+}
+/**
+ * Synchronous generator context manager
+ */
+export class GeneratorContextManager {
+    constructor(generator) {
+        this.isFinalized = false;
+        this.generator = generator;
+    }
+    *[Symbol.iterator]() {
+        try {
+            yield* this.generator;
+        }
+        finally {
+            this.cleanup();
+        }
+    }
+    next() {
+        try {
+            return this.generator.next();
+        }
+        catch (error) {
+            this.cleanup();
+            throw error;
+        }
+    }
+    return(value) {
+        try {
+            return this.generator.return(value);
+        }
+        finally {
+            this.cleanup();
+        }
+    }
+    throw(error) {
+        try {
+            return this.generator.throw(error);
+        }
+        finally {
+            this.cleanup();
+        }
+    }
+    cleanup() {
+        if (!this.isFinalized) {
+            this.isFinalized = true;
+            try {
+                // Ensure generator is properly closed
+                if (typeof this.generator.return === 'function') {
+                    this.generator.return();
+                }
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    [Symbol.dispose]() {
+        this.cleanup();
+    }
+}
+/**
+ * Decorator to wrap async generator functions with context management
+ */
+export function asAsyncContextManager(generatorFunction) {
+    return (...args) => {
+        const generator = generatorFunction(...args);
+        return new AsyncGeneratorContextManager(generator);
+    };
+}
+/**
+ * Decorator to wrap sync generator functions with context management
+ */
+export function asContextManager(generatorFunction) {
+    return (...args) => {
+        const generator = generatorFunction(...args);
+        return new GeneratorContextManager(generator);
+    };
+}
+/**
+ * Stream wrapper that provides automatic cleanup and error handling
+ */
+export class StreamWrapper {
+    constructor(stream, cleanup) {
+        this.isActive = true;
+        this.cleanup = null;
+        this.stream = stream;
+        this.cleanup = cleanup || null;
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            while (this.isActive) {
+                const result = await this.stream.next();
+                if (result.done) {
+                    break;
+                }
+                yield result.value;
+            }
+        }
+        finally {
+            await this.close();
+        }
+    }
+    async close() {
+        if (this.isActive) {
+            this.isActive = false;
+            try {
+                // Close the stream
+                if (typeof this.stream.return === 'function') {
+                    await this.stream.return();
+                }
+            }
+            catch (error) {
+                // Ignore stream closure errors
+            }
+            // Run custom cleanup
+            if (this.cleanup) {
+                try {
+                    await this.cleanup();
+                }
+                catch (error) {
+                    console.warn('Stream cleanup failed:', error);
+                }
+            }
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+}
+/**
+ * Timeout wrapper for streams
+ */
+export class StreamTimeoutWrapper extends StreamWrapper {
+    constructor(stream, timeoutMs, cleanup) {
+        super(stream, cleanup);
+        this.timeoutId = null;
+        this.timeout = timeoutMs;
+        this.lastActivity = Date.now();
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            this.startTimeout();
+            while (this.isActive) {
+                const result = await this.stream.next();
+                this.updateActivity();
+                if (result.done) {
+                    break;
+                }
+                yield result.value;
+            }
+        }
+        finally {
+            this.clearTimeout();
+            await this.close();
+        }
+    }
+    startTimeout() {
+        this.timeoutId = setTimeout(() => {
+            if (Date.now() - this.lastActivity > this.timeout) {
+                this.close().catch(console.error);
+            }
+        }, this.timeout);
+    }
+    clearTimeout() {
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+    updateActivity() {
+        this.lastActivity = Date.now();
+    }
+    async close() {
+        this.clearTimeout();
+        await super.close();
+    }
+}
+/**
+ * Batch processing wrapper for streams
+ */
+export class StreamBatchProcessor {
+    constructor(stream, batchSize, cleanup) {
+        this.currentBatch = [];
+        this.isActive = true;
+        this.cleanup = null;
+        this.stream = stream;
+        this.batchSize = batchSize;
+        this.cleanup = cleanup || null;
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            while (this.isActive) {
+                const result = await this.stream.next();
+                if (result.done) {
+                    // Yield remaining items in batch
+                    if (this.currentBatch.length > 0) {
+                        yield [...this.currentBatch];
+                        this.currentBatch = [];
+                    }
+                    break;
+                }
+                this.currentBatch.push(result.value);
+                if (this.currentBatch.length >= this.batchSize) {
+                    yield [...this.currentBatch];
+                    this.currentBatch = [];
+                }
+            }
+        }
+        finally {
+            await this.close();
+        }
+    }
+    async close() {
+        if (this.isActive) {
+            this.isActive = false;
+            try {
+                if (typeof this.stream.return === 'function') {
+                    await this.stream.return();
+                }
+            }
+            catch (error) {
+                // Ignore stream closure errors
+            }
+            if (this.cleanup) {
+                try {
+                    await this.cleanup();
+                }
+                catch (error) {
+                    console.warn('Stream cleanup failed:', error);
+                }
+            }
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+}
+/**
+ * Error recovery wrapper for streams
+ */
+export class StreamErrorRecovery extends StreamWrapper {
+    constructor(stream, maxRetries = 3, errorHandler, cleanup) {
+        super(stream, cleanup);
+        this.retryCount = 0;
+        this.errorHandler = null;
+        this.maxRetries = maxRetries;
+        this.errorHandler = errorHandler || null;
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            while (this.isActive && this.retryCount <= this.maxRetries) {
+                try {
+                    const result = await this.stream.next();
+                    if (result.done) {
+                        break;
+                    }
+                    // Reset retry count on successful read
+                    this.retryCount = 0;
+                    yield result.value;
+                }
+                catch (error) {
+                    this.retryCount++;
+                    const shouldRetry = this.errorHandler ?
+                        this.errorHandler(error) :
+                        this.retryCount <= this.maxRetries;
+                    if (!shouldRetry) {
+                        throw error;
+                    }
+                    // Wait before retry
+                    await new Promise(resolve => setTimeout(resolve, Math.pow(2, this.retryCount) * 1000));
+                }
+            }
+        }
+        finally {
+            await this.close();
+        }
+    }
+}
+/**
+ * Utility functions for creating context-managed streams
+ */
+export const streamUtils = {
+    /**
+     * Wrap an async generator with automatic cleanup
+     */
+    wrap: (stream, cleanup) => {
+        return new StreamWrapper(stream, cleanup);
+    },
+    /**
+     * Add timeout handling to a stream
+     */
+    withTimeout: (stream, timeoutMs, cleanup) => {
+        return new StreamTimeoutWrapper(stream, timeoutMs, cleanup);
+    },
+    /**
+     * Add batch processing to a stream
+     */
+    withBatching: (stream, batchSize, cleanup) => {
+        return new StreamBatchProcessor(stream, batchSize, cleanup);
+    },
+    /**
+     * Add error recovery to a stream
+     */
+    withErrorRecovery: (stream, maxRetries = 3, errorHandler, cleanup) => {
+        return new StreamErrorRecovery(stream, maxRetries, errorHandler, cleanup);
+    },
+};
+export default {
+    AsyncGeneratorContextManager,
+    GeneratorContextManager,
+    StreamWrapper,
+    StreamTimeoutWrapper,
+    StreamBatchProcessor,
+    StreamErrorRecovery,
+    asAsyncContextManager,
+    asContextManager,
+    streamUtils,
+};

package/dist/utils/usage.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Usage tracking and analytics utilities
+ * Equivalent to Python's utils/usage/usage.py
+ */
+export interface UsageMetrics {
+    timestamp: Date;
+    organization_id: string;
+    user_id?: string;
+    operation_type: 'extraction' | 'generation' | 'analysis' | 'batch' | 'streaming';
+    model_used: string;
+    provider: string;
+    tokens_used: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    cost_usd: number;
+    latency_ms: number;
+    success: boolean;
+    error_type?: string;
+    request_id: string;
+    metadata?: Record<string, any>;
+}
+export interface UsageAggregation {
+    period: 'hour' | 'day' | 'week' | 'month';
+    start_time: Date;
+    end_time: Date;
+    total_requests: number;
+    successful_requests: number;
+    failed_requests: number;
+    total_tokens: number;
+    total_cost_usd: number;
+    average_latency_ms: number;
+    operations_by_type: Record<string, number>;
+    models_by_usage: Record<string, {
+        requests: number;
+        tokens: number;
+        cost: number;
+    }>;
+    providers_by_usage: Record<string, {
+        requests: number;
+        tokens: number;
+        cost: number;
+    }>;
+    error_breakdown: Record<string, number>;
+}
+export declare class UsageTracker {
+    private metrics;
+    recordUsage(metrics: Omit<UsageMetrics, 'timestamp'>): void;
+    getUsageAggregation(organizationId: string, period: 'hour' | 'day' | 'week' | 'month', startTime?: Date, endTime?: Date): UsageAggregation;
+    private getPeriodStart;
+}
+declare const _default: {
+    UsageTracker: typeof UsageTracker;
+};
+export default _default;
+//# sourceMappingURL=usage.d.ts.map

package/dist/utils/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../src/utils/usage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,IAAI,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,YAAY,GAAG,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,CAAC;IACjF,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAC1C,UAAU,EAAE,IAAI,CAAC;IACjB,QAAQ,EAAE,IAAI,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE;QAC9B,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;IACH,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE;QACjC,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;IACH,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAsB;IAErC,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,GAAG,IAAI;IAS3D,mBAAmB,CACjB,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,EACzC,SAAS,CAAC,EAAE,IAAI,EAChB,OAAO,CAAC,EAAE,IAAI,GACb,gBAAgB;IAoEnB,OAAO,CAAC,cAAc;CAsBvB;;;;AAGD,wBAEE"}

package/dist/utils/usage.js

@@ -0,0 +1,97 @@
+/**
+ * Usage tracking and analytics utilities
+ * Equivalent to Python's utils/usage/usage.py
+ */
+export class UsageTracker {
+    constructor() {
+        this.metrics = [];
+    }
+    recordUsage(metrics) {
+        const usage = {
+            ...metrics,
+            timestamp: new Date(),
+        };
+        this.metrics.push(usage);
+    }
+    getUsageAggregation(organizationId, period, startTime, endTime) {
+        const now = new Date();
+        const start = startTime || this.getPeriodStart(period, now);
+        const end = endTime || now;
+        const relevantMetrics = this.metrics.filter(m => m.organization_id === organizationId &&
+            m.timestamp >= start &&
+            m.timestamp <= end);
+        const totalRequests = relevantMetrics.length;
+        const successfulRequests = relevantMetrics.filter(m => m.success).length;
+        const failedRequests = totalRequests - successfulRequests;
+        const totalTokens = relevantMetrics.reduce((sum, m) => sum + m.tokens_used.total, 0);
+        const totalCost = relevantMetrics.reduce((sum, m) => sum + m.cost_usd, 0);
+        const averageLatency = totalRequests > 0 ?
+            relevantMetrics.reduce((sum, m) => sum + m.latency_ms, 0) / totalRequests : 0;
+        const operationsByType = {};
+        relevantMetrics.forEach(m => {
+            operationsByType[m.operation_type] = (operationsByType[m.operation_type] || 0) + 1;
+        });
+        const modelsByUsage = {};
+        relevantMetrics.forEach(m => {
+            if (!modelsByUsage[m.model_used]) {
+                modelsByUsage[m.model_used] = { requests: 0, tokens: 0, cost: 0 };
+            }
+            modelsByUsage[m.model_used].requests++;
+            modelsByUsage[m.model_used].tokens += m.tokens_used.total;
+            modelsByUsage[m.model_used].cost += m.cost_usd;
+        });
+        const providersByUsage = {};
+        relevantMetrics.forEach(m => {
+            if (!providersByUsage[m.provider]) {
+                providersByUsage[m.provider] = { requests: 0, tokens: 0, cost: 0 };
+            }
+            providersByUsage[m.provider].requests++;
+            providersByUsage[m.provider].tokens += m.tokens_used.total;
+            providersByUsage[m.provider].cost += m.cost_usd;
+        });
+        const errorBreakdown = {};
+        relevantMetrics.filter(m => !m.success).forEach(m => {
+            const errorType = m.error_type || 'unknown';
+            errorBreakdown[errorType] = (errorBreakdown[errorType] || 0) + 1;
+        });
+        return {
+            period,
+            start_time: start,
+            end_time: end,
+            total_requests: totalRequests,
+            successful_requests: successfulRequests,
+            failed_requests: failedRequests,
+            total_tokens: totalTokens,
+            total_cost_usd: totalCost,
+            average_latency_ms: averageLatency,
+            operations_by_type: operationsByType,
+            models_by_usage: modelsByUsage,
+            providers_by_usage: providersByUsage,
+            error_breakdown: errorBreakdown,
+        };
+    }
+    getPeriodStart(period, from) {
+        const start = new Date(from);
+        switch (period) {
+            case 'hour':
+                start.setMinutes(0, 0, 0);
+                break;
+            case 'day':
+                start.setHours(0, 0, 0, 0);
+                break;
+            case 'week':
+                start.setDate(start.getDate() - start.getDay());
+                start.setHours(0, 0, 0, 0);
+                break;
+            case 'month':
+                start.setDate(1);
+                start.setHours(0, 0, 0, 0);
+                break;
+        }
+        return start;
+    }
+}
+// Export class but not types in default export
+export default {
+    UsageTracker,
+};

package/dist/utils/webhook_secrets.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Webhook secret management utilities for secure webhook verification
+ * Equivalent to Python's webhook_secrets.py
+ */
+export interface WebhookConfig {
+    secret: string;
+    tolerance?: number;
+    encoding?: 'hex' | 'base64';
+}
+export interface WebhookHeaders {
+    signature?: string;
+    timestamp?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Generate webhook signature for payload
+ */
+export declare function generateSignature(payload: string | Buffer, secret: string, timestamp?: number, encoding?: 'hex' | 'base64'): string;
+/**
+ * Verify webhook signature
+ */
+export declare function verifySignature(payload: string | Buffer, signature: string, secret: string, timestamp?: number, config?: Partial<WebhookConfig>): boolean;
+/**
+ * Parse webhook headers for signature and timestamp
+ */
+export declare function parseWebhookHeaders(headers: WebhookHeaders): {
+    signature?: string;
+    timestamp?: number;
+};
+/**
+ * Verify webhook request
+ */
+export declare function verifyWebhookRequest(payload: string | Buffer, headers: WebhookHeaders, secret: string, config?: Partial<WebhookConfig>): boolean;
+/**
+ * Generate webhook secret
+ */
+export declare function generateWebhookSecret(length?: number): string;
+/**
+ * Create webhook signature header
+ */
+export declare function createSignatureHeader(payload: string | Buffer, secret: string, encoding?: 'hex' | 'base64'): {
+    signature: string;
+    timestamp: number;
+};
+/**
+ * Webhook middleware for Express-like frameworks
+ */
+export declare function webhookMiddleware(secret: string, config?: Partial<WebhookConfig>): (req: any, res: any, next: any) => any;
+declare const _default: {
+    generateSignature: typeof generateSignature;
+    verifySignature: typeof verifySignature;
+    parseWebhookHeaders: typeof parseWebhookHeaders;
+    verifyWebhookRequest: typeof verifyWebhookRequest;
+    generateWebhookSecret: typeof generateWebhookSecret;
+    createSignatureHeader: typeof createSignatureHeader;
+    webhookMiddleware: typeof webhookMiddleware;
+};
+export default _default;
+//# sourceMappingURL=webhook_secrets.d.ts.map

package/dist/utils/webhook_secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook_secrets.d.ts","sourceRoot":"","sources":["../../src/utils/webhook_secrets.ts"],"names":[],"mappings":"AAEA;;;GAGG;AAEH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC;CAC7B;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACnC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,QAAQ,GAAE,KAAK,GAAG,QAAgB,GACjC,MAAM,CASR;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC,OAAO,CA4BT;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,GAAG;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAYA;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC,OAAO,CAQT;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,MAAW,GAAG,MAAM,CAMjE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,KAAK,GAAG,QAAgB,GACjC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAK1C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,IAC3E,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,GAAG,SActC;;;;;;;;;;AAED,wBAQE"}