@goscribe/server 1.6.0 → 1.7.0

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>;

package/dist/src/lib/storage.js

@@ -0,0 +1,71 @@
+// src/server/lib/storage.ts
+import { createClient } from '@supabase/supabase-js';
+import { v4 as uuidv4 } from 'uuid';
+// Initialize Supabase Storage
+const supabaseUrl = process.env.SUPABASE_URL;
+const supabaseServiceKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+if (!supabaseUrl || !supabaseServiceKey) {
+    throw new Error('Missing required Supabase environment variables: SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY');
+}
+const supabase = createClient(supabaseUrl, supabaseServiceKey);
+const bucketName = process.env.SUPABASE_BUCKET || 'media';
+export async function uploadToSupabase(fileBuffer, fileName, contentType, makePublic = false) {
+    const objectKey = `podcasts/${uuidv4()}_${fileName}`;
+    // Upload the file to Supabase Storage
+    const { data, error } = await supabase.storage
+        .from(bucketName)
+        .upload(objectKey, fileBuffer, {
+        contentType,
+        upsert: false,
+    });
+    if (error) {
+        throw new Error(`Failed to upload file to Supabase: ${error.message}`);
+    }
+    const url = `${supabaseUrl}/storage/v1/object/public/${bucketName}/${objectKey}`;
+    // Generate signed URL for private files
+    let signedUrl;
+    if (!makePublic) {
+        const { data: signedUrlData, error: signedUrlError } = await supabase.storage
+            .from(bucketName)
+            .createSignedUrl(objectKey, 24 * 60 * 60); // 24 hours
+        if (signedUrlError) {
+            throw new Error(`Failed to generate signed URL: ${signedUrlError.message}`);
+        }
+        signedUrl = signedUrlData.signedUrl;
+    }
+    return {
+        url,
+        signedUrl,
+        objectKey,
+    };
+}
+export async function generateSignedUrl(objectKey, expiresInHours = 24) {
+    const { data, error } = await supabase.storage
+        .from(bucketName)
+        .createSignedUrl(objectKey, expiresInHours * 60 * 60);
+    if (error) {
+        throw new Error(`Failed to generate signed URL: ${error.message}`);
+    }
+    return data.signedUrl;
+}
+export async function deleteFromSupabase(objectKey) {
+    const { error } = await supabase.storage
+        .from(bucketName)
+        .remove([objectKey]);
+    if (error) {
+        throw new Error(`Failed to delete file from Supabase: ${error.message}`);
+    }
+}
+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
+    // 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
+    // File privacy is controlled by bucket policy in Supabase Storage
+}
+// Export supabase client for direct access if needed
+export const supabaseClient = supabase;

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

@@ -0,0 +1,10 @@
+import Stripe from 'stripe';
+export declare const stripe: Stripe | null;
+/**
+ * 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/src/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/src/lib/validation.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+/**
+ * Common validation schemas
+ */
+export declare const commonSchemas: {
+    id: z.ZodString;
+    email: z.ZodString;
+    url: z.ZodString;
+    pagination: z.ZodObject<{
+        page: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    search: z.ZodObject<{
+        query: z.ZodString;
+    }, z.core.$strip>;
+};
+/**
+ * Enums for type safety
+ */
+export declare const ArtifactType: z.ZodEnum<{
+    WORKSHEET: "WORKSHEET";
+    STUDY_GUIDE: "STUDY_GUIDE";
+    FLASHCARD_SET: "FLASHCARD_SET";
+    MEETING_SUMMARY: "MEETING_SUMMARY";
+    PODCAST_EPISODE: "PODCAST_EPISODE";
+}>;
+export declare const Difficulty: z.ZodEnum<{
+    EASY: "EASY";
+    MEDIUM: "MEDIUM";
+    HARD: "HARD";
+}>;
+export declare const QuestionType: z.ZodEnum<{
+    MULTIPLE_CHOICE: "MULTIPLE_CHOICE";
+    TEXT: "TEXT";
+    NUMERIC: "NUMERIC";
+    TRUE_FALSE: "TRUE_FALSE";
+    MATCHING: "MATCHING";
+    FILL_IN_THE_BLANK: "FILL_IN_THE_BLANK";
+}>;
+/**
+ * Validation helper that throws ValidationError
+ */
+export declare function validateSchema<T extends z.ZodType>(schema: T, data: unknown): z.infer<T>;
+/**
+ * Sanitize string inputs
+ */
+export declare function sanitizeString(input: string, maxLength?: number): string;
+/**
+ * Validate ownership
+ */
+export declare function validateOwnership(ownerId: string, userId: string): void;

package/dist/src/lib/validation.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { ValidationError } from './errors.js';
+/**
+ * Common validation schemas
+ */
+export const commonSchemas = {
+    id: z.string().cuid(),
+    email: z.string().email(),
+    url: z.string().url(),
+    pagination: z.object({
+        page: z.number().int().positive().default(1),
+        limit: z.number().int().positive().max(100).default(20),
+    }),
+    search: z.object({
+        query: z.string().min(1).max(200),
+    }),
+};
+/**
+ * Enums for type safety
+ */
+export const ArtifactType = z.enum([
+    'STUDY_GUIDE',
+    'FLASHCARD_SET',
+    'WORKSHEET',
+    'MEETING_SUMMARY',
+    'PODCAST_EPISODE',
+]);
+export const Difficulty = z.enum(['EASY', 'MEDIUM', 'HARD']);
+export const QuestionType = z.enum([
+    'MULTIPLE_CHOICE',
+    'TEXT',
+    'NUMERIC',
+    'TRUE_FALSE',
+    'MATCHING',
+    'FILL_IN_THE_BLANK',
+]);
+/**
+ * Validation helper that throws ValidationError
+ */
+export function validateSchema(schema, data) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        const errors = result.error.message;
+        throw new ValidationError(`Validation failed: ${errors}`);
+    }
+    return result.data;
+}
+/**
+ * Sanitize string inputs
+ */
+export function sanitizeString(input, maxLength = 10000) {
+    return input
+        .trim()
+        .slice(0, maxLength)
+        .replace(/[<>]/g, ''); // Basic XSS prevention
+}
+/**
+ * Validate ownership
+ */
+export function validateOwnership(ownerId, userId) {
+    if (ownerId !== userId) {
+        throw new ValidationError('You do not have permission to access this resource');
+    }
+}

package/dist/src/lib/workspace-kb.d.ts

@@ -0,0 +1,5 @@
+/** Meta.kind value for the private, auto-managed KB attached to each workspace. */
+export declare const WORKSPACE_KB_KIND = "workspace";
+export declare function isWorkspaceManagedKb(kb: {
+    meta: unknown;
+}): boolean;

package/dist/src/lib/workspace-kb.js

@@ -0,0 +1,7 @@
+/** Meta.kind value for the private, auto-managed KB attached to each workspace. */
+export const WORKSPACE_KB_KIND = 'workspace';
+export function isWorkspaceManagedKb(kb) {
+    if (!kb.meta || typeof kb.meta !== 'object')
+        return false;
+    return kb.meta.kind === WORKSPACE_KB_KIND;
+}

package/dist/src/repositories/artifact.repository.d.ts

@@ -0,0 +1,64 @@
+import type { ArtifactType, Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+export declare class ArtifactRepository extends BaseRepository {
+    constructor(db: PrismaClient);
+    /**
+     * Fetch an artifact if the user can access the containing workspace
+     * (owner or member).
+     */
+    findByIdAccessible(artifactId: string, userId: string, include?: Prisma.ArtifactInclude): Prisma.Prisma__ArtifactClient<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        createdById: string | null;
+        type: ArtifactType;
+        workspaceId: string;
+        difficulty: import("@prisma/client").Difficulty | null;
+        estimatedTime: string | null;
+        isArchived: boolean;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/client").JsonValue | null;
+        worksheetConfig: import("@prisma/client/runtime/client").JsonValue | null;
+        imageObjectKey: string | null;
+    } | null, null, import("@prisma/client/runtime/client").DefaultArgs, {
+        omit: Prisma.GlobalOmitConfig | undefined;
+    }>;
+    findByIdAndTypeAccessible(artifactId: string, type: ArtifactType, userId: string, include?: Prisma.ArtifactInclude): Prisma.Prisma__ArtifactClient<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        createdById: string | null;
+        type: ArtifactType;
+        workspaceId: string;
+        difficulty: import("@prisma/client").Difficulty | null;
+        estimatedTime: string | null;
+        isArchived: boolean;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/client").JsonValue | null;
+        worksheetConfig: import("@prisma/client/runtime/client").JsonValue | null;
+        imageObjectKey: string | null;
+    } | null, null, import("@prisma/client/runtime/client").DefaultArgs, {
+        omit: Prisma.GlobalOmitConfig | undefined;
+    }>;
+    listByWorkspaceAndType(workspaceId: string, type: ArtifactType, userId: string, args?: Omit<Prisma.ArtifactFindManyArgs, 'where'>): Prisma.PrismaPromise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        createdById: string | null;
+        type: ArtifactType;
+        workspaceId: string;
+        difficulty: import("@prisma/client").Difficulty | null;
+        estimatedTime: string | null;
+        isArchived: boolean;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/client").JsonValue | null;
+        worksheetConfig: import("@prisma/client/runtime/client").JsonValue | null;
+        imageObjectKey: string | null;
+    }[]>;
+}

package/dist/src/repositories/artifact.repository.js

@@ -0,0 +1,40 @@
+import { BaseRepository } from './base.repository.js';
+import { workspaceAccessWhere } from './workspace.repository.js';
+export class ArtifactRepository extends BaseRepository {
+    constructor(db) {
+        super(db);
+    }
+    /**
+     * Fetch an artifact if the user can access the containing workspace
+     * (owner or member).
+     */
+    findByIdAccessible(artifactId, userId, include) {
+        return this.db.artifact.findFirst({
+            where: {
+                id: artifactId,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include,
+        });
+    }
+    findByIdAndTypeAccessible(artifactId, type, userId, include) {
+        return this.db.artifact.findFirst({
+            where: {
+                id: artifactId,
+                type,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include,
+        });
+    }
+    listByWorkspaceAndType(workspaceId, type, userId, args) {
+        return this.db.artifact.findMany({
+            ...args,
+            where: {
+                workspaceId,
+                type,
+                workspace: workspaceAccessWhere(userId),
+            },
+        });
+    }
+}

package/dist/src/repositories/base.repository.d.ts

@@ -0,0 +1,14 @@
+import type { PrismaClient } from '@prisma/client';
+import { logger } from '../lib/logger.js';
+/**
+ * Shared base class for repositories.
+ *
+ * Repositories own data access. They wrap a Prisma client and expose
+ * intent-revealing methods (e.g. `findAccessibleById(workspaceId, userId)`)
+ * so that the shape of `where` clauses doesn't leak into services/routers.
+ */
+export declare abstract class BaseRepository {
+    protected readonly db: PrismaClient;
+    protected readonly logger: typeof logger;
+    constructor(db: PrismaClient);
+}

package/dist/src/repositories/base.repository.js

@@ -0,0 +1,14 @@
+import { logger } from '../lib/logger.js';
+/**
+ * Shared base class for repositories.
+ *
+ * Repositories own data access. They wrap a Prisma client and expose
+ * intent-revealing methods (e.g. `findAccessibleById(workspaceId, userId)`)
+ * so that the shape of `where` clauses doesn't leak into services/routers.
+ */
+export class BaseRepository {
+    constructor(db) {
+        this.db = db;
+        this.logger = logger;
+    }
+}