@retab/node 0.0.48 → 0.0.52

package/dist/utils/stream_context_managers.js

@@ -1,380 +0,0 @@
-/**
- * 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

@@ -1,57 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,97 +0,0 @@
-/**
- * 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

@@ -1,59 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}