@goscribe/server 1.5.0 → 1.7.0

package/dist/src/lib/logger.js

@@ -0,0 +1,364 @@
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
+})(LogLevel || (LogLevel = {}));
+// Icons and colors for different log levels
+const LOG_STYLES = {
+    [LogLevel.ERROR]: {
+        icon: '❌',
+        color: '\x1b[31m', // Red
+        bgColor: '\x1b[41m', // Red background
+        bold: '\x1b[1m',
+    },
+    [LogLevel.WARN]: {
+        icon: '⚠️ ',
+        color: '\x1b[33m', // Yellow
+        bgColor: '\x1b[43m', // Yellow background
+        bold: '\x1b[1m',
+    },
+    [LogLevel.INFO]: {
+        icon: 'ℹ️ ',
+        color: '\x1b[36m', // Cyan
+        bgColor: '\x1b[46m', // Cyan background
+        bold: '\x1b[1m',
+    },
+    [LogLevel.DEBUG]: {
+        icon: '🐛',
+        color: '\x1b[35m', // Magenta
+        bgColor: '\x1b[45m', // Magenta background
+        bold: '\x1b[1m',
+    },
+    [LogLevel.TRACE]: {
+        icon: '🔍',
+        color: '\x1b[37m', // White
+        bgColor: '\x1b[47m', // White background
+        bold: '\x1b[1m',
+    },
+};
+// Context icons for common services
+const CONTEXT_ICONS = {
+    'SERVER': '🖥️ ',
+    'HTTP': '🌐',
+    'API': '🔌',
+    'AUTH': '🔐',
+    'DATABASE': '🗄️ ',
+    'DB': '🗄️ ',
+    'TRPC': '⚡',
+    'WORKSPACE': '📁',
+    'WORKSHEET': '📝',
+    'FLASHCARD': '🃏',
+    'STUDYGUIDE': '📚',
+    'PODCAST': '🎙️ ',
+    'MEETING': '🤝',
+    'CHAT': '💬',
+    'FILE': '📄',
+    'STORAGE': '💾',
+    'CACHE': '⚡',
+    'MIDDLEWARE': '🔧',
+    'PERFORMANCE': '⚡',
+    'SECURITY': '🛡️ ',
+    'VALIDATION': '✅',
+    'ERROR': '❌',
+    'SUCCESS': '✅',
+    'LOGGER': '📋',
+};
+class Logger {
+    constructor(config = {}) {
+        this.config = {
+            level: LogLevel.INFO,
+            enableConsole: true,
+            enableFile: false,
+            logDir: './logs',
+            maxFileSize: 10 * 1024 * 1024, // 10MB
+            maxFiles: 5,
+            format: 'pretty',
+            ...config,
+        };
+        if (this.config.enableFile) {
+            this.setupFileLogging();
+        }
+    }
+    setupFileLogging() {
+        if (!this.config.logDir)
+            return;
+        // Ensure log directory exists
+        if (!existsSync(this.config.logDir)) {
+            mkdirSync(this.config.logDir, { recursive: true });
+        }
+        const logFile = join(this.config.logDir, `app-${new Date().toISOString().split('T')[0]}.log`);
+        this.logStream = createWriteStream(logFile, { flags: 'a' });
+    }
+    shouldLog(level) {
+        return level <= this.config.level;
+    }
+    formatLogEntry(entry) {
+        if (this.config.format === 'json') {
+            return JSON.stringify(entry) + '\n';
+        }
+        // Pretty format with enhanced styling
+        const timestamp = this.formatTimestamp(entry.timestamp);
+        const level = this.formatLevel(entry.level);
+        const context = entry.context ? this.formatContext(entry.context) : '';
+        const metadata = entry.metadata ? this.formatMetadata(entry.metadata) : '';
+        const error = entry.error ? this.formatError(entry.error) : '';
+        return `${timestamp} ${level} ${context}${entry.message}${metadata}${error}`;
+    }
+    formatLevel(level) {
+        const levelNum = LogLevel[level];
+        const style = LOG_STYLES[levelNum];
+        return `${style.color}${style.bold}${level.padEnd(5)}\x1b[0m`;
+    }
+    formatTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        const time = date.toLocaleTimeString('en-US', {
+            hour12: false,
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+        });
+        return `\x1b[90m${time}\x1b[0m`; // Gray color
+    }
+    formatContext(context) {
+        if (typeof context !== 'string')
+            return '';
+        const icon = CONTEXT_ICONS[context.toUpperCase()] || '📦';
+        return `\x1b[94m${icon}${context}\x1b[0m `; // Blue color
+    }
+    formatMetadata(metadata) {
+        const entries = Object.entries(metadata)
+            .map(([key, value]) => {
+            const formattedValue = this.formatValue(value);
+            return `\x1b[93m${key}\x1b[0m=\x1b[96m${formattedValue}\x1b[0m`;
+        })
+            .join(' \x1b[90m|\x1b[0m ');
+        return entries ? `\n  \x1b[90m└─\x1b[0m \x1b[90m{\x1b[0m ${entries} \x1b[90m}\x1b[0m` : '';
+    }
+    formatValue(value) {
+        if (value === null)
+            return '\x1b[90mnull\x1b[0m';
+        if (value === undefined)
+            return '\x1b[90mundefined\x1b[0m';
+        if (typeof value === 'boolean')
+            return value ? '\x1b[92mtrue\x1b[0m' : '\x1b[91mfalse\x1b[0m';
+        if (typeof value === 'number')
+            return `\x1b[95m${value}\x1b[0m`;
+        if (typeof value === 'string')
+            return `\x1b[96m"${value}"\x1b[0m`;
+        if (typeof value === 'object') {
+            if (Array.isArray(value)) {
+                const items = value.map(item => this.formatValue(item)).join('\x1b[90m, \x1b[0m');
+                return `\x1b[90m[\x1b[0m${items}\x1b[90m]\x1b[0m`;
+            }
+            const objEntries = Object.entries(value)
+                .map(([k, v]) => `\x1b[93m${k}\x1b[0m:\x1b[96m${this.formatValue(v)}\x1b[0m`)
+                .join('\x1b[90m, \x1b[0m');
+            return `\x1b[90m{\x1b[0m${objEntries}\x1b[90m}\x1b[0m`;
+        }
+        return `\x1b[96m${String(value)}\x1b[0m`;
+    }
+    formatError(error) {
+        let errorStr = `\n  \x1b[90m└─\x1b[0m \x1b[31m❌ \x1b[93m${error.name}\x1b[0m: \x1b[91m${error.message}\x1b[0m`;
+        if (error.stack) {
+            const stackLines = error.stack.split('\n').slice(1, 4); // Show first 3 stack lines
+            errorStr += `\n    \x1b[90m└─ Stack:\x1b[0m`;
+            stackLines.forEach((line, index) => {
+                const isLast = index === stackLines.length - 1;
+                const connector = isLast ? '└─' : '├─';
+                errorStr += `\n      \x1b[90m${connector} \x1b[0m\x1b[90m${line.trim()}\x1b[0m`;
+            });
+        }
+        return errorStr;
+    }
+    log(level, message, context, metadata, error) {
+        if (!this.shouldLog(level))
+            return;
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level: LogLevel[level],
+            message,
+            context,
+            metadata,
+            error: error ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            } : undefined,
+        };
+        const formattedLog = this.formatLogEntry(entry);
+        if (this.config.enableConsole) {
+            // Enhanced console output with icons and colors
+            const style = LOG_STYLES[level];
+            const reset = '\x1b[0m';
+            // Create a beautiful log line with proper spacing and colors
+            const logLine = `${style.color}${style.icon} ${formattedLog}${reset}`;
+            console.log(logLine);
+        }
+        if (this.config.enableFile && this.logStream) {
+            this.logStream.write(formattedLog + '\n');
+        }
+    }
+    error(message, contextOrError, metadata, error) {
+        if (contextOrError instanceof Error) {
+            this.log(LogLevel.ERROR, message, undefined, metadata, contextOrError);
+        }
+        else {
+            this.log(LogLevel.ERROR, message, contextOrError, metadata, error);
+        }
+    }
+    warn(message, contextOrMeta, metadata) {
+        if (typeof contextOrMeta === 'object' && contextOrMeta !== null) {
+            this.log(LogLevel.WARN, message, undefined, contextOrMeta);
+        }
+        else {
+            this.log(LogLevel.WARN, message, contextOrMeta, metadata);
+        }
+    }
+    info(message, contextOrMeta, metadata) {
+        if (typeof contextOrMeta === 'object' && contextOrMeta !== null) {
+            this.log(LogLevel.INFO, message, undefined, contextOrMeta);
+        }
+        else {
+            this.log(LogLevel.INFO, message, contextOrMeta, metadata);
+        }
+    }
+    debug(message, contextOrMeta, metadata) {
+        if (typeof contextOrMeta === 'object' && contextOrMeta !== null) {
+            this.log(LogLevel.DEBUG, message, undefined, contextOrMeta);
+        }
+        else {
+            this.log(LogLevel.DEBUG, message, contextOrMeta, metadata);
+        }
+    }
+    trace(message, context, metadata) {
+        this.log(LogLevel.TRACE, message, context, metadata);
+    }
+    // Convenience methods for common use cases
+    http(method, url, statusCode, responseTime, context) {
+        const statusIcon = this.getHttpStatusIcon(statusCode);
+        const responseTimeStr = responseTime ? `${responseTime}ms` : undefined;
+        const metadata = {
+            method,
+            url,
+            statusCode,
+            responseTime: responseTimeStr,
+        };
+        this.info(`${statusIcon} ${method} ${url} - ${statusCode}`, context || 'HTTP', metadata);
+    }
+    getHttpStatusIcon(statusCode) {
+        if (statusCode >= 200 && statusCode < 300)
+            return '✅';
+        if (statusCode >= 300 && statusCode < 400)
+            return '↩️ ';
+        if (statusCode >= 400 && statusCode < 500)
+            return '⚠️ ';
+        if (statusCode >= 500)
+            return '❌';
+        return '❓';
+    }
+    database(operation, table, duration, context) {
+        const operationIcon = this.getDatabaseOperationIcon(operation);
+        const durationStr = duration ? `${duration}ms` : undefined;
+        const metadata = {
+            operation,
+            table,
+            duration: durationStr,
+        };
+        this.debug(`${operationIcon} ${operation} on ${table}`, context || 'DATABASE', metadata);
+    }
+    getDatabaseOperationIcon(operation) {
+        const op = operation.toUpperCase();
+        if (op.includes('SELECT'))
+            return '🔍';
+        if (op.includes('INSERT'))
+            return '➕';
+        if (op.includes('UPDATE'))
+            return '✏️ ';
+        if (op.includes('DELETE'))
+            return '🗑️ ';
+        if (op.includes('CREATE'))
+            return '🏗️ ';
+        if (op.includes('DROP'))
+            return '💥';
+        return '🗄️ ';
+    }
+    auth(action, userId, context) {
+        const metadata = {
+            action,
+            userId,
+        };
+        this.info(`Auth ${action}`, context, metadata);
+    }
+    trpc(procedure, input, output, duration, context) {
+        const metadata = {
+            procedure,
+            input: input ? JSON.stringify(input) : undefined,
+            output: output ? JSON.stringify(output) : undefined,
+            duration: duration ? `${duration}ms` : undefined,
+        };
+        this.debug(`tRPC ${procedure}`, context, metadata);
+    }
+    // Method to update configuration at runtime
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        if (newConfig.enableFile && !this.logStream) {
+            this.setupFileLogging();
+        }
+        else if (!newConfig.enableFile && this.logStream) {
+            this.logStream.end();
+            this.logStream = undefined;
+        }
+    }
+    // Progress indicator for long-running operations
+    progress(message, current, total, context) {
+        const percentage = Math.round((current / total) * 100);
+        const progressBar = this.createProgressBar(percentage);
+        this.info(`${progressBar} ${message} (${current}/${total} - ${percentage}%)`, context || 'PROGRESS');
+    }
+    createProgressBar(percentage, width = 20) {
+        const filled = Math.round((percentage / 100) * width);
+        const empty = width - filled;
+        const bar = '█'.repeat(filled) + '░'.repeat(empty);
+        return `[${bar}]`;
+    }
+    // Success and failure helpers
+    success(message, context, metadata) {
+        this.info(`✅ ${message}`, context, metadata);
+    }
+    failure(message, context, metadata, error) {
+        this.error(`❌ ${message}`, context, metadata, error);
+    }
+    // Method to close file streams (useful for graceful shutdown)
+    close() {
+        if (this.logStream) {
+            this.logStream.end();
+        }
+    }
+}
+// Create default logger instance
+const defaultConfig = {
+    level: process.env.NODE_ENV === 'production' ? LogLevel.INFO : LogLevel.DEBUG,
+    enableConsole: true,
+    enableFile: process.env.NODE_ENV === 'production',
+    logDir: './logs',
+    format: process.env.NODE_ENV === 'production' ? 'json' : 'pretty',
+};
+export const logger = new Logger(defaultConfig);
+// Export the Logger class for custom instances
+export { Logger };
+// Graceful shutdown handling
+process.on('SIGINT', () => {
+    logger.info('Received SIGINT, closing logger...');
+    logger.close();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    logger.info('Received SIGTERM, closing logger...');
+    logger.close();
+    process.exit(0);
+});

package/dist/src/lib/pdf.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Thin wrapper around `pdf-parse` that returns plain text + page count.
+ *
+ * pdf-parse is loaded lazily and via a deep import to avoid the package's
+ * top-level "test" code that runs when the module index is loaded directly.
+ */
+export interface ExtractedPdf {
+    text: string;
+    numPages: number;
+}
+export declare function extractPdfText(buffer: Buffer): Promise<ExtractedPdf>;

package/dist/src/lib/pdf.js

@@ -0,0 +1,11 @@
+export async function extractPdfText(buffer) {
+    // Deep import skips pdf-parse's top-level demo block (`if (!module.parent)`).
+    // @ts-ignore - no types ship for the deep file
+    const mod = await import('pdf-parse/lib/pdf-parse.js');
+    const pdfParse = mod.default ?? mod;
+    const data = await pdfParse(buffer);
+    return {
+        text: data.text ?? '',
+        numPages: data.numpages ?? 0,
+    };
+}

package/dist/src/lib/prisma.d.ts

@@ -0,0 +1,3 @@
+import { PrismaClient } from "../../generated/prisma/client.js";
+export { ArtifactType, ActivityLogCategory, ActivityLogStatus, InvoiceType, } from "../../generated/prisma/client.js";
+export declare const prisma: PrismaClient;

package/dist/src/lib/prisma.js

@@ -0,0 +1,15 @@
+import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "../../generated/prisma/client.js";
+export { ArtifactType, ActivityLogCategory, ActivityLogStatus, InvoiceType, } from "../../generated/prisma/client.js";
+const globalForPrisma = globalThis;
+function createPrismaClient() {
+    const connectionString = process.env.DATABASE_URL;
+    if (!connectionString) {
+        throw new Error("DATABASE_URL is not set");
+    }
+    const adapter = new PrismaPg({ connectionString });
+    return new PrismaClient({ adapter });
+}
+export const prisma = globalForPrisma.prisma ?? createPrismaClient();
+if (process.env.NODE_ENV !== "production")
+    globalForPrisma.prisma = prisma;

package/dist/src/lib/pusher.d.ts

@@ -0,0 +1,38 @@
+import Pusher from 'pusher';
+export declare const pusher: Pusher;
+export declare class PusherService {
+    static emitUserEvent(userId: string, eventName: string, data: any): Promise<void>;
+    static emitTaskComplete(workspaceId: string, event: string, data: any): Promise<void>;
+    static emitAnalysisComplete(workspaceId: string, analysisType: string, result: any): Promise<void>;
+    static emitStudyGuideComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitFlashcardComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitWorksheetComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitWorksheetGenerationStart(workspaceId: string): Promise<void>;
+    static emitWorksheetNew(workspaceId: string, worksheet: any): Promise<void>;
+    static emitWorksheetGenerationComplete(workspaceId: string, worksheet: any): Promise<void>;
+    static emitPodcastComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitOverallComplete(workspaceId: string, filename: string, artifacts: any): Promise<void>;
+    static emitError(workspaceId: string, error: string, analysisType?: string): Promise<void>;
+    static emitAnalysisProgress(workspaceId: string, progress: any): Promise<void>;
+    static emitChannelEvent(channelId: string, event: string, data: any): Promise<void>;
+    static emitMemberJoined(workspaceId: string, member: any): Promise<void>;
+    static emitProfileUpdate(userId: string): Promise<void>;
+    static emitLibraryUpdate(userId: string): Promise<void>;
+    static emitNotificationNew(userId: string, data: {
+        notificationId: string;
+        type: string;
+        title: string;
+        unreadCount: number;
+        createdAt: string;
+    }): Promise<void>;
+    static emitNotificationReadState(userId: string, data: {
+        unreadCount: number;
+        timestamp?: string;
+    }): Promise<void>;
+    static emitPaymentSuccess(userId: string, data: {
+        type: 'topup' | 'subscription';
+        resourceType?: string;
+        quantity?: string;
+    }): Promise<void>;
+}
+export default PusherService;

package/dist/src/lib/pusher.js

@@ -0,0 +1,170 @@
+import Pusher from 'pusher';
+import { logger } from './logger.js';
+// Server-side Pusher instance
+export const pusher = new Pusher({
+    appId: process.env.PUSHER_APP_ID || '',
+    key: process.env.PUSHER_KEY || '',
+    secret: process.env.PUSHER_SECRET || '',
+    cluster: process.env.PUSHER_CLUSTER || 'us2',
+    useTLS: true,
+});
+// Pusher service for managing notifications
+export class PusherService {
+    static async emitUserEvent(userId, eventName, data) {
+        try {
+            const channel = `user_${userId}`;
+            await pusher.trigger(channel, eventName, data);
+            logger.info(`📡 Pusher user event sent: ${eventName} to ${channel}`);
+        }
+        catch (error) {
+            logger.error('Pusher user event error:', 'PUSHER', { error, userId, eventName });
+        }
+    }
+    // Emit task completion notification
+    static async emitTaskComplete(workspaceId, event, data) {
+        try {
+            const channel = `workspace_${workspaceId}`;
+            const eventName = event;
+            await pusher.trigger(channel, eventName, data);
+            logger.info(`📡 Pusher notification sent: ${eventName} to ${channel}`);
+        }
+        catch (error) {
+            logger.error('Pusher notification error:', 'PUSHER', { error });
+        }
+    }
+    // Emit AI analysis completion
+    static async emitAnalysisComplete(workspaceId, analysisType, result) {
+        await this.emitTaskComplete(workspaceId, `${analysisType}_ended`, {
+            type: analysisType,
+            result,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    // Emit study guide completion
+    static async emitStudyGuideComplete(workspaceId, artifact) {
+        await this.emitTaskComplete(workspaceId, 'study_guide_generation_complete', {
+            artifactId: artifact.id,
+            title: artifact.title,
+            status: 'completed'
+        });
+    }
+    // Emit flashcard completion
+    static async emitFlashcardComplete(workspaceId, artifact) {
+        await this.emitAnalysisComplete(workspaceId, 'flashcard', {
+            artifactId: artifact.id,
+            title: artifact.title,
+            status: 'completed'
+        });
+    }
+    // Emit worksheet completion
+    static async emitWorksheetComplete(workspaceId, artifact) {
+        await this.emitAnalysisComplete(workspaceId, 'worksheet', {
+            artifactId: artifact.id,
+            title: artifact.title,
+            status: 'completed'
+        });
+    }
+    // Emit worksheet generation start notification
+    static async emitWorksheetGenerationStart(workspaceId) {
+        await this.emitTaskComplete(workspaceId, 'worksheet_generation_start', {});
+    }
+    // Emit new worksheet notification
+    static async emitWorksheetNew(workspaceId, worksheet) {
+        await this.emitTaskComplete(workspaceId, 'worksheet_new', { worksheet });
+    }
+    // Emit worksheet generation completion notification
+    static async emitWorksheetGenerationComplete(workspaceId, worksheet) {
+        await this.emitTaskComplete(workspaceId, 'worksheet_generation_complete', { worksheet });
+    }
+    // Emit podcast completion
+    static async emitPodcastComplete(workspaceId, artifact) {
+        await this.emitAnalysisComplete(workspaceId, 'podcast', {
+            artifactId: artifact.id,
+            title: artifact.title,
+            status: 'completed'
+        });
+    }
+    // Emit overall analysis completion
+    static async emitOverallComplete(workspaceId, filename, artifacts) {
+        await this.emitTaskComplete(workspaceId, 'analysis_ended', {
+            filename,
+            artifacts,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    // Emit error notification
+    static async emitError(workspaceId, error, analysisType) {
+        const event = analysisType ? `${analysisType}_error` : 'analysis_error';
+        await this.emitTaskComplete(workspaceId, event, {
+            error,
+            analysisType,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    // Emit analysis progress update (single event for all progress updates)
+    static async emitAnalysisProgress(workspaceId, progress) {
+        try {
+            const channel = `workspace_${workspaceId}`;
+            await pusher.trigger(channel, 'analysis_progress', progress);
+            logger.info(`📡 Analysis progress sent to ${channel}: ${progress.status}`);
+        }
+        catch (error) {
+            logger.error('Pusher progress notification error:', 'PUSHER', { error });
+        }
+    }
+    // Emit channel-specific events (for chat messages)
+    static async emitChannelEvent(channelId, event, data) {
+        try {
+            const channel = channelId; // Use channelId directly as channel name
+            const eventName = event;
+            await pusher.trigger(channel, eventName, data);
+            logger.info(`Pusher notification sent: ${eventName} to ${channel}`);
+        }
+        catch (error) {
+            logger.error('Pusher channel notification error:', 'PUSHER', { error });
+        }
+    }
+    // Emit member joined notification
+    static async emitMemberJoined(workspaceId, member) {
+        await this.emitTaskComplete(workspaceId, 'member_joined', { member });
+    }
+    // Emit profile update notification
+    static async emitProfileUpdate(userId) {
+        await this.emitUserEvent(userId, 'profile_updated', {
+            userId,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    // Emit library (folders/workspaces) update notification
+    static async emitLibraryUpdate(userId) {
+        await this.emitUserEvent(userId, 'library_updated', {
+            userId,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    static async emitNotificationNew(userId, data) {
+        await this.emitUserEvent(userId, 'notification_new', data);
+    }
+    static async emitNotificationReadState(userId, data) {
+        await this.emitUserEvent(userId, 'notification_read_state_changed', {
+            ...data,
+            timestamp: data.timestamp ?? new Date().toISOString(),
+        });
+    }
+    // Emit payment success (top-up or subscription)
+    static async emitPaymentSuccess(userId, data) {
+        try {
+            const channel = `user_${userId}`;
+            const eventName = 'payment_success';
+            await pusher.trigger(channel, eventName, {
+                ...data,
+                timestamp: new Date().toISOString(),
+            });
+            logger.info(`📡 Pusher payment success sent: ${eventName} to ${channel}`);
+        }
+        catch (error) {
+            logger.error('Pusher payment success error:', 'PUSHER', { error });
+        }
+    }
+}
+export default PusherService;

package/dist/src/lib/retry.d.ts

@@ -0,0 +1,15 @@
+export interface RetryOptions {
+    /** Maximum number of attempts (default: 3) */
+    maxRetries?: number;
+    /** Base delay in ms for exponential backoff (default: 2000) */
+    baseDelayMs?: number;
+    /** Timeout per attempt in ms (default: 300000 = 5 minutes) */
+    timeoutMs?: number;
+    /** Label for logging (optional) */
+    label?: string;
+}
+/**
+ * Wraps an async function with retry logic and exponential backoff.
+ * Throws the last error if all attempts fail.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/src/lib/retry.js

@@ -0,0 +1,37 @@
+import { logger } from './logger.js';
+/**
+ * Wraps an async function with retry logic and exponential backoff.
+ * Throws the last error if all attempts fail.
+ */
+export async function withRetry(fn, options = {}) {
+    const { maxRetries = 3, baseDelayMs = 2000, timeoutMs = 300000, label = 'operation', } = options;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            logger.info(`[retry] ${label} attempt ${attempt}/${maxRetries}`);
+            // Create an AbortController for per-attempt timeout
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const result = await fn();
+                clearTimeout(timeoutId);
+                return result;
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                throw error;
+            }
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            logger.error(`[retry] ${label} attempt ${attempt} failed: ${lastError.message}`);
+            if (attempt < maxRetries) {
+                const delay = Math.pow(2, attempt) * baseDelayMs;
+                logger.info(`[retry] ${label} retrying in ${delay}ms...`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    logger.error(`[retry] ${label} all ${maxRetries} attempts failed`);
+    throw lastError;
+}

package/dist/src/lib/storage.d.ts

@@ -0,0 +1,11 @@
+export interface UploadResult {
+    url: string;
+    signedUrl?: string;
+    objectKey: string;
+}
+export declare function uploadToSupabase(fileBuffer: Buffer, fileName: string, contentType: string, makePublic?: boolean): Promise<UploadResult>;
+export declare function generateSignedUrl(objectKey: string, expiresInHours?: number): Promise<string>;
+export declare function deleteFromSupabase(objectKey: string): Promise<void>;
+export declare function makeFilePublic(objectKey: string): Promise<void>;
+export declare function makeFilePrivate(objectKey: string): Promise<void>;
+export declare const supabaseClient: import("@supabase/supabase-js").SupabaseClient<any, "public", "public", any, any>;