@goscribe/server 1.3.4 → 1.5.0

package/dist/services/payment.service.js

@@ -0,0 +1,368 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from './base.service.js';
+import { stripe } from '../lib/stripe.js';
+import { env } from '../lib/env.js';
+import { getUserUsage, getUserPlanLimits } from './usage.service.js';
+import { notifyPaymentSucceeded, notifySubscriptionActivated, notifySubscriptionPaymentSucceeded, } from './notification.service.js';
+import { upsertSubscriptionFromStripe } from './subscription.service.js';
+/** Stripe Checkout URLs contain the session id (cs_…); we only store the URL in DB. */
+const CHECKOUT_SESSION_ID_IN_URL = /cs_[a-zA-Z0-9]+/;
+async function reuseCheckoutUrlIfSessionStillOpen(stripeClient, db, existing, lockKey) {
+    const url = existing.stripeSessionId;
+    if (!url)
+        return null;
+    const idMatch = url.match(CHECKOUT_SESSION_ID_IN_URL);
+    if (!idMatch) {
+        await db.idempotencyRecord.updateMany({
+            where: { id: existing.id, activeLockKey: lockKey },
+            data: { activeLockKey: null, status: 'expired' },
+        });
+        return null;
+    }
+    try {
+        const session = await stripeClient.checkout.sessions.retrieve(idMatch[0]);
+        if (session.status === 'open') {
+            return url;
+        }
+        await db.idempotencyRecord.updateMany({
+            where: { id: existing.id, activeLockKey: lockKey },
+            data: {
+                activeLockKey: null,
+                status: session.status === 'complete' ? 'completed' : 'expired',
+            },
+        });
+        return null;
+    }
+    catch {
+        await db.idempotencyRecord.updateMany({
+            where: { id: existing.id, activeLockKey: lockKey },
+            data: { activeLockKey: null, status: 'expired' },
+        });
+        return null;
+    }
+}
+export class PaymentService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async getPlans(userId) {
+        const plans = await this.db.plan.findMany({
+            where: { active: true },
+            include: { limit: true },
+            orderBy: { price: 'asc' },
+        });
+        // Anonymous callers (pricing page) don't get per-user `isActive`.
+        if (!userId) {
+            return plans.map((plan) => ({ ...plan, isActive: false }));
+        }
+        const activeSubscriptions = await this.db.subscription.findMany({
+            where: { userId, status: 'active' },
+        });
+        return plans.map((plan) => ({
+            ...plan,
+            isActive: activeSubscriptions.some((sub) => sub.planId === plan.id),
+        }));
+    }
+    async createCheckoutSession(userId, input) {
+        if (!stripe) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'Stripe not configured',
+            });
+        }
+        const user = await this.db.user.findUnique({ where: { id: userId } });
+        if (!user)
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'User not found' });
+        const lockKey = `pending_${userId}_${input.planId}`;
+        let attempt = null;
+        let retryCount = 0;
+        while (retryCount < 3) {
+            try {
+                attempt = await this.db.idempotencyRecord.create({
+                    data: {
+                        userId,
+                        planId: input.planId,
+                        activeLockKey: lockKey,
+                        status: 'pending',
+                    },
+                });
+                break;
+            }
+            catch (err) {
+                if (err.code === 'P2002') {
+                    const existing = await this.db.idempotencyRecord.findUnique({
+                        where: { activeLockKey: lockKey },
+                    });
+                    if (!existing) {
+                        retryCount++;
+                        continue;
+                    }
+                    const isStale = Date.now() - existing.updatedAt.getTime() > 24 * 60 * 60 * 1000;
+                    if (isStale) {
+                        const result = await this.db.idempotencyRecord.updateMany({
+                            where: { id: existing.id, activeLockKey: lockKey },
+                            data: { activeLockKey: null, status: 'expired' },
+                        });
+                        if (result.count > 0) {
+                            retryCount++;
+                            continue;
+                        }
+                    }
+                    if (existing.stripeSessionId && stripe) {
+                        const reusable = await reuseCheckoutUrlIfSessionStillOpen(stripe, this.db, existing, lockKey);
+                        if (reusable)
+                            return { url: reusable };
+                        retryCount++;
+                        continue;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 800));
+                    retryCount++;
+                    continue;
+                }
+                throw err;
+            }
+        }
+        if (!attempt) {
+            throw new TRPCError({ code: 'CONFLICT', message: 'Concurrent request' });
+        }
+        const plan = await this.db.plan.findUnique({ where: { id: input.planId } });
+        if (!plan)
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Plan not found' });
+        try {
+            const successUrl = env.STRIPE_SUCCESS_URL.includes('session_id=')
+                ? env.STRIPE_SUCCESS_URL
+                : `${env.STRIPE_SUCCESS_URL}${env.STRIPE_SUCCESS_URL.includes('?') ? '&' : '?'}session_id={CHECKOUT_SESSION_ID}`;
+            const session = await stripe.checkout.sessions.create({
+                customer: user.stripe_customer_id || undefined,
+                customer_email: user.stripe_customer_id ? undefined : user.email || undefined,
+                line_items: [{ price: plan.stripePriceId, quantity: 1 }],
+                mode: plan.interval ? 'subscription' : 'payment',
+                subscription_data: plan.interval
+                    ? {
+                        metadata: {
+                            userId,
+                            planId: plan.id,
+                            attemptId: attempt.id,
+                        },
+                    }
+                    : undefined,
+                success_url: successUrl,
+                cancel_url: env.STRIPE_CANCEL_URL,
+                metadata: {
+                    userId,
+                    planId: plan.id,
+                    attemptId: attempt.id,
+                },
+            }, {
+                idempotencyKey: attempt.id,
+            });
+            await this.db.idempotencyRecord.update({
+                where: { id: attempt.id },
+                data: { stripeSessionId: session.url },
+            });
+            return { url: session.url };
+        }
+        catch (error) {
+            await this.db.idempotencyRecord.update({
+                where: { id: attempt.id },
+                data: { status: 'failed', activeLockKey: null },
+            });
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: error.message,
+            });
+        }
+    }
+    async confirmCheckoutSuccess(userId, input) {
+        if (!stripe) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'Stripe not configured',
+            });
+        }
+        const session = await stripe.checkout.sessions.retrieve(input.sessionId, {
+            expand: ['line_items', 'subscription'],
+        });
+        const metadata = session.metadata || {};
+        if (metadata.userId !== userId) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'This checkout session does not belong to the current user',
+            });
+        }
+        if (session.status !== 'complete') {
+            return { confirmed: false, reason: 'checkout_not_complete' };
+        }
+        const plan = metadata.planId
+            ? await this.db.plan.findUnique({ where: { id: metadata.planId } })
+            : null;
+        if (session.mode === 'payment' && session.payment_status === 'paid') {
+            await notifyPaymentSucceeded(this.db, {
+                userId,
+                planId: metadata.planId,
+                planName: plan?.name || metadata.planType,
+                stripeSessionId: session.id,
+                amountPaid: session.amount_total ?? undefined,
+            });
+            return { confirmed: true, kind: 'payment' };
+        }
+        if (session.mode === 'subscription') {
+            const stripeSubscriptionId = typeof session.subscription === 'string'
+                ? session.subscription
+                : session.subscription?.id;
+            if (stripeSubscriptionId) {
+                await upsertSubscriptionFromStripe(stripeSubscriptionId);
+                await notifySubscriptionActivated(this.db, {
+                    userId,
+                    planId: metadata.planId,
+                    planName: plan?.name || metadata.planType,
+                    stripeSubscriptionId,
+                });
+                if (session.payment_status === 'paid') {
+                    await notifySubscriptionPaymentSucceeded(this.db, {
+                        userId,
+                        planId: metadata.planId,
+                        planName: plan?.name || metadata.planType,
+                        stripeInvoiceId: `checkout_${session.id}`,
+                        amountPaid: session.amount_total ?? undefined,
+                    });
+                }
+            }
+            return { confirmed: true, kind: 'subscription' };
+        }
+        return { confirmed: false, reason: 'unsupported_mode' };
+    }
+    async createResourcePurchaseSession(userId, input) {
+        if (!stripe) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'Stripe is not configured on the server',
+            });
+        }
+        const user = await this.db.user.findUnique({ where: { id: userId } });
+        if (!user) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'User not found' });
+        }
+        const resourcePrice = await this.db.resourcePrice.findUnique({
+            where: { resourceType: input.resourceType },
+        });
+        if (!resourcePrice) {
+            throw new TRPCError({
+                code: 'PRECONDITION_FAILED',
+                message: 'Price not set',
+            });
+        }
+        const lockKey = `topup_${userId}_${input.resourceType}`;
+        let attempt = null;
+        let retryCount = 0;
+        while (retryCount < 3) {
+            try {
+                attempt = await this.db.idempotencyRecord.create({
+                    data: {
+                        userId,
+                        resourceType: input.resourceType,
+                        activeLockKey: lockKey,
+                        status: 'pending',
+                    },
+                });
+                break;
+            }
+            catch (err) {
+                if (err.code === 'P2002') {
+                    const existing = await this.db.idempotencyRecord.findUnique({
+                        where: { activeLockKey: lockKey },
+                    });
+                    if (!existing) {
+                        retryCount++;
+                        continue;
+                    }
+                    const isStale = Date.now() - existing.updatedAt.getTime() > 24 * 60 * 60 * 1000;
+                    if (isStale) {
+                        const result = await this.db.idempotencyRecord.updateMany({
+                            where: { id: existing.id, activeLockKey: lockKey },
+                            data: { activeLockKey: null, status: 'expired' },
+                        });
+                        if (result.count > 0) {
+                            retryCount++;
+                            continue;
+                        }
+                    }
+                    if (existing.stripeSessionId && stripe) {
+                        const reusable = await reuseCheckoutUrlIfSessionStillOpen(stripe, this.db, existing, lockKey);
+                        if (reusable)
+                            return { url: reusable };
+                        retryCount++;
+                        continue;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 800));
+                    retryCount++;
+                    continue;
+                }
+                throw err;
+            }
+        }
+        if (!attempt) {
+            throw new TRPCError({ code: 'CONFLICT', message: 'Concurrent request' });
+        }
+        try {
+            const resourceName = input.resourceType
+                .split('_')
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+                .join(' ');
+            const session = await stripe.checkout.sessions.create({
+                customer: user.stripe_customer_id || undefined,
+                line_items: [
+                    {
+                        price_data: {
+                            currency: 'usd',
+                            product_data: {
+                                name: `Add-on: extra ${resourceName}s`,
+                                description: `Purchase of ${input.quantity} additional ${resourceName}(s)`,
+                            },
+                            unit_amount: resourcePrice.priceCents,
+                        },
+                        quantity: input.quantity,
+                    },
+                ],
+                mode: 'payment',
+                success_url: `${env.STRIPE_SUCCESS_URL}?success=true`,
+                cancel_url: env.STRIPE_CANCEL_URL,
+                metadata: {
+                    userId,
+                    resourceType: input.resourceType,
+                    quantity: input.quantity.toString(),
+                    isPurchase: 'true',
+                    attemptId: attempt.id,
+                },
+                invoice_creation: { enabled: true },
+            }, {
+                idempotencyKey: attempt.id,
+            });
+            await this.db.idempotencyRecord.update({
+                where: { id: attempt.id },
+                data: { stripeSessionId: session.url },
+            });
+            return { url: session.url };
+        }
+        catch (error) {
+            await this.db.idempotencyRecord.update({
+                where: { id: attempt.id },
+                data: { status: 'failed', activeLockKey: null },
+            });
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: error.message,
+            });
+        }
+    }
+    async getUsageOverview(userId) {
+        const [usage, limits] = await Promise.all([
+            getUserUsage(userId),
+            getUserPlanLimits(userId),
+        ]);
+        return { usage, limits, hasActivePlan: !!limits };
+    }
+    getResourcePrices() {
+        return this.db.resourcePrice.findMany();
+    }
+}

package/dist/services/podcast.service.d.ts

@@ -0,0 +1,267 @@
+import type { PrismaClient } from '@prisma/client';
+import { z } from 'zod';
+import { BaseService } from './base.service.js';
+export declare const speakerSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        host: "host";
+        guest: "guest";
+        expert: "expert";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const podcastInputSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    userPrompt: z.ZodString;
+    speakers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            host: "host";
+            guest: "guest";
+            expert: "expert";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    speed: z.ZodDefault<z.ZodNumber>;
+    generateIntro: z.ZodDefault<z.ZodBoolean>;
+    generateOutro: z.ZodDefault<z.ZodBoolean>;
+    segmentByTopics: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PodcastInput = z.infer<typeof podcastInputSchema>;
+export declare const podcastMetadataSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    totalDuration: z.ZodNumber;
+    speakers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            host: "host";
+            guest: "guest";
+            expert: "expert";
+        }>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        executiveSummary: z.ZodString;
+        learningObjectives: z.ZodArray<z.ZodString>;
+        keyConcepts: z.ZodArray<z.ZodString>;
+        followUpActions: z.ZodArray<z.ZodString>;
+        targetAudience: z.ZodString;
+        prerequisites: z.ZodArray<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    generatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare class PodcastService extends BaseService {
+    constructor(db: PrismaClient);
+    listEpisodes(userId: string, workspaceId: string): Promise<{
+        id: string;
+        title: string;
+        description: string | null;
+        metadata: {
+            title: string;
+            totalDuration: number;
+            speakers: {
+                id: string;
+                role: "host" | "guest" | "expert";
+                name?: string | undefined;
+            }[];
+            summary: {
+                executiveSummary: string;
+                learningObjectives: string[];
+                keyConcepts: string[];
+                followUpActions: string[];
+                targetAudience: string;
+                prerequisites: string[];
+                tags: string[];
+            };
+            generatedAt: string;
+            description?: string | undefined;
+        } | null;
+        imageUrl: string | null;
+        segments: ({
+            id: string;
+            title: string;
+            audioUrl: string;
+            objectKey: string;
+            startTime: number;
+            duration: number;
+            order: number;
+        } | {
+            id: string;
+            title: string;
+            audioUrl: null;
+            objectKey: string | null;
+            startTime: number;
+            duration: number;
+            order: number;
+        })[];
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        createdById: string | null;
+        isArchived: boolean;
+    }[]>;
+    getEpisode(userId: string, episodeId: string): Promise<{
+        id: string;
+        title: string;
+        description: string | undefined;
+        metadata: {
+            title: string;
+            totalDuration: number;
+            speakers: {
+                id: string;
+                role: "host" | "guest" | "expert";
+                name?: string | undefined;
+            }[];
+            summary: {
+                executiveSummary: string;
+                learningObjectives: string[];
+                keyConcepts: string[];
+                followUpActions: string[];
+                targetAudience: string;
+                prerequisites: string[];
+                tags: string[];
+            };
+            generatedAt: string;
+            description?: string | undefined;
+        };
+        imageUrl: string | null;
+        segments: ({
+            id: string;
+            title: string;
+            content: string;
+            audioUrl: string;
+            objectKey: string;
+            startTime: number;
+            duration: number;
+            keyPoints: string[];
+            order: number;
+        } | {
+            id: string;
+            title: string;
+            content: string;
+            audioUrl: null;
+            objectKey: string | null;
+            startTime: number;
+            duration: number;
+            keyPoints: string[];
+            order: number;
+        })[];
+        content: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    generateEpisode(userId: string, input: {
+        workspaceId: string;
+        podcastData: PodcastInput;
+    }): Promise<{
+        id: string;
+        title: any;
+        description: string | undefined;
+        metadata: {
+            title: any;
+            description: string | undefined;
+            totalDuration: number;
+            summary: any;
+            speakers: {
+                id: string;
+                role: "host" | "guest" | "expert";
+                name?: string | undefined;
+            }[];
+            generatedAt: string;
+        };
+        content: string;
+    }>;
+    deleteSegment(segmentId: string): Promise<{
+        meta: import("@prisma/client/runtime/library").JsonValue | null;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+        artifactId: string;
+        content: string;
+        objectKey: string | null;
+        duration: number;
+        order: number;
+        startTime: number;
+        audioUrl: string | null;
+        keyPoints: string[];
+    }>;
+    getEpisodeSchema(userId: string, episodeId: string): Promise<{
+        segments: {
+            id: string;
+            title: string;
+            startTime: number;
+            duration: number;
+            keyPoints: string[];
+            order: number;
+        }[];
+        summary: {
+            executiveSummary: string;
+            learningObjectives: string[];
+            keyConcepts: string[];
+            followUpActions: string[];
+            targetAudience: string;
+            prerequisites: string[];
+            tags: string[];
+        };
+        metadata: {
+            title: string;
+            description: string | undefined;
+            totalDuration: number;
+            speakers: {
+                id: string;
+                role: "host" | "guest" | "expert";
+                name?: string | undefined;
+            }[];
+        };
+    }>;
+    updateEpisode(userId: string, input: {
+        episodeId: string;
+        title?: string;
+        description?: string;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        title: string;
+        isArchived: boolean;
+        difficulty: import("@prisma/client").$Enums.Difficulty | null;
+        estimatedTime: string | null;
+        createdById: string | null;
+        description: string | null;
+        generating: boolean;
+        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+        worksheetConfig: import("@prisma/client/runtime/library").JsonValue | null;
+        imageObjectKey: string | null;
+    }>;
+    deleteEpisode(userId: string, episodeId: string): Promise<boolean>;
+    getSegment(userId: string, segmentId: string): Promise<{
+        id: string;
+        title: string;
+        content: string;
+        startTime: number;
+        duration: number;
+        order: number;
+        keyPoints: string[];
+        audioUrl: string | null;
+        objectKey: string | null;
+        meta: import("@prisma/client/runtime/library").JsonValue;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    getAvailableVoices(): {
+        id: string;
+        name: string;
+        description: string;
+    }[];
+}