@goscribe/server 1.3.0 → 1.3.1

package/dist/lib/pusher.js

@@ -10,6 +10,16 @@ export const pusher = new Pusher({
 });
 // 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 {
@@ -19,7 +29,7 @@ export class PusherService {
             logger.info(`📡 Pusher notification sent: ${eventName} to ${channel}`);
         }
         catch (error) {
-            console.error('❌ Pusher notification error:', error);
+            logger.error('Pusher notification error:', 'PUSHER', { error });
         }
     }
     // Emit AI analysis completion
@@ -32,7 +42,7 @@ export class PusherService {
     }
     // Emit study guide completion
     static async emitStudyGuideComplete(workspaceId, artifact) {
-        await this.emitAnalysisComplete(workspaceId, 'studyguide', {
+        await this.emitTaskComplete(workspaceId, 'study_guide_generation_complete', {
             artifactId: artifact.id,
             title: artifact.title,
             status: 'completed'
@@ -54,6 +64,18 @@ export class PusherService {
             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', {
@@ -87,7 +109,7 @@ export class PusherService {
             logger.info(`📡 Analysis progress sent to ${channel}: ${progress.status}`);
         }
         catch (error) {
-            console.error('❌ Pusher progress notification error:', error);
+            logger.error('Pusher progress notification error:', 'PUSHER', { error });
         }
     }
     // Emit channel-specific events (for chat messages)
@@ -96,10 +118,52 @@ export class PusherService {
             const channel = channelId; // Use channelId directly as channel name
             const eventName = event;
             await pusher.trigger(channel, eventName, data);
-            console.log(`📡 Pusher notification sent: ${eventName} to ${channel}`);
+            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) {
-            console.error('❌ Pusher notification error:', error);
+            logger.error('Pusher payment success error:', 'PUSHER', { error });
         }
     }
 }

package/dist/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/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/lib/storage.js

@@ -60,12 +60,12 @@ export async function makeFilePublic(objectKey) {
     // In Supabase, files are public by default when uploaded to public buckets
     // For private buckets, you would need to update the bucket policy
     // This function is kept for compatibility but may not be needed
-    console.log(`File ${objectKey} is already public in Supabase Storage`);
+    // File is already public in Supabase Storage
 }
 export async function makeFilePrivate(objectKey) {
     // In Supabase, you would need to update the bucket policy to make files private
     // This function is kept for compatibility but may not be needed
-    console.log(`File ${objectKey} privacy is controlled by bucket policy in Supabase Storage`);
+    // File privacy is controlled by bucket policy in Supabase Storage
 }
 // Export supabase client for direct access if needed
 export const supabaseClient = supabase;

package/dist/lib/stripe.d.ts

@@ -0,0 +1,9 @@
+export declare const stripe: any;
+/**
+ * Creates a Stripe customer for a user.
+ *
+ * @param email - User's email
+ * @param name - User's name
+ * @returns The Stripe customer ID
+ */
+export declare function createStripeCustomer(email: string, name?: string): Promise<string | null>;

package/dist/lib/stripe.js

@@ -0,0 +1,36 @@
+import Stripe from 'stripe';
+import { env } from './env.js';
+import { logger } from './logger.js';
+if (!env.STRIPE_SECRET_KEY) {
+    logger.warn('STRIPE_SECRET_KEY is not set. Stripe functionality will be disabled.', 'STRIPE');
+}
+export const stripe = env.STRIPE_SECRET_KEY
+    ? new Stripe(env.STRIPE_SECRET_KEY, {
+        apiVersion: '2026-02-25.clover',
+    })
+    : null;
+/**
+ * Creates a Stripe customer for a user.
+ *
+ * @param email - User's email
+ * @param name - User's name
+ * @returns The Stripe customer ID
+ */
+export async function createStripeCustomer(email, name) {
+    if (!stripe) {
+        logger.error('Stripe is not initialized. Cannot create customer.', 'STRIPE');
+        return null;
+    }
+    try {
+        const customer = await stripe.customers.create({
+            email,
+            name,
+        });
+        logger.info(`Stripe customer created for ${email}: ${customer.id}`, 'STRIPE');
+        return customer.id;
+    }
+    catch (error) {
+        logger.error(`Failed to create Stripe customer for ${email}: ${error.message}`, 'STRIPE');
+        return null;
+    }
+}

package/dist/lib/subscription_service.d.ts

@@ -0,0 +1,37 @@
+import Stripe from 'stripe';
+/**
+ * Handle checkout.session.completed event
+ */
+export declare function handleCheckoutCompleted(event: Stripe.Event): Promise<void>;
+/**
+ * Handle customer.subscription.created event
+ */
+export declare function handleSubscriptionCreated(event: Stripe.Event): Promise<void>;
+/**
+ * Handle customer.subscription.updated event
+ */
+export declare function handleSubscriptionUpdated(event: Stripe.Event): Promise<void>;
+/**
+ * Handle customer.subscription.deleted event
+ */
+export declare function handleSubscriptionDeleted(event: Stripe.Event): Promise<void>;
+/**
+ * Handle invoice.paid event
+ */
+export declare function handleInvoicePaid(event: Stripe.Event): Promise<void>;
+/**
+ * Handle invoice.payment_failed event
+ */
+export declare function handlePaymentFailed(event: Stripe.Event): Promise<void>;
+/**
+ * Handle payment_intent.payment_failed event (One-time payments)
+ */
+export declare function handlePaymentIntentFailed(event: Stripe.Event): Promise<void>;
+/**
+ * Get the storage limit for a user based on their active subscription
+ */
+export declare function getUserStorageLimit(userId: string): Promise<number>;
+/**
+ * Core logic to sync Stripe subscription state with Prisma database
+ */
+export declare function upsertSubscriptionFromStripe(subscriptionIdOrObject: Stripe.Subscription | string): Promise<void>;