briyah 1.0.0

package/dist/app/balance.service.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalanceService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class BalanceService {
+    userId;
+    configService;
+    balanceFilePath;
+    markupFilePath;
+    startingBalance;
+    balanceMessageService;
+    constructor(userId, configService, balanceMessageService) {
+        this.userId = userId;
+        this.configService = configService;
+        this.balanceMessageService = balanceMessageService;
+        if (!process.env.STARTING_BALANCE) {
+            throw new Error('STARTING_BALANCE environment variable is required');
+        }
+        this.startingBalance = parseFloat(process.env.STARTING_BALANCE);
+        if (isNaN(this.startingBalance)) {
+            throw new Error('STARTING_BALANCE must be a valid number');
+        }
+        if (this.startingBalance < 0) {
+            throw new Error('STARTING_BALANCE must be non-negative');
+        }
+        const userconfigPath = this.configService.getUserConfigDir();
+        this.balanceFilePath = path.join(userconfigPath, 'balance');
+        const commonConfigPath = this.configService.getCommonConfigDir();
+        this.markupFilePath = path.join(commonConfigPath, 'markup');
+    }
+    getBalance() {
+        try {
+            if (!fs.existsSync(this.balanceFilePath)) {
+                this.saveBalance(this.startingBalance);
+                return this.startingBalance;
+            }
+            const balanceStr = fs.readFileSync(this.balanceFilePath, 'utf-8').trim();
+            const balance = parseFloat(balanceStr);
+            if (isNaN(balance)) {
+                console.error(`Balance file corrupted for user ${this.userId}, resetting to starting balance`);
+                this.saveBalance(this.startingBalance);
+                return this.startingBalance;
+            }
+            return balance;
+        }
+        catch (error) {
+            console.error(`Error reading balance for user ${this.userId}:`, error);
+            return this.startingBalance;
+        }
+    }
+    getMarkup() {
+        try {
+            if (!fs.existsSync(this.markupFilePath)) {
+                this.saveMarkup(0);
+                return 0;
+            }
+            const markupStr = fs.readFileSync(this.markupFilePath, 'utf-8').trim();
+            const markup = parseFloat(markupStr);
+            if (isNaN(markup)) {
+                console.error(`Markup file corrupted, resetting to 0`);
+                this.saveMarkup(0);
+                return 0;
+            }
+            return markup;
+        }
+        catch (error) {
+            console.error(`Error reading markup:`, error);
+            return 0;
+        }
+    }
+    hasSufficientBalance() {
+        const balance = this.getBalance();
+        return balance >= 0;
+    }
+    decrementBalance(amount, markup = 0) {
+        if (amount < 0) {
+            throw new Error('Amount must be positive');
+        }
+        const currentBalance = this.getBalance();
+        const newBalance = currentBalance - amount;
+        this.saveBalance(newBalance);
+        const currentMarkup = this.getMarkup();
+        const newMarkup = currentMarkup + markup;
+        this.saveMarkup(newMarkup);
+    }
+    addBalance(amount) {
+        if (amount <= 0) {
+            throw new Error('Amount must be positive');
+        }
+        const currentBalance = this.getBalance();
+        const newBalance = currentBalance + amount;
+        this.saveBalance(newBalance);
+    }
+    saveBalance(balance) {
+        try {
+            const userconfigPath = this.configService.getUserConfigDir();
+            if (!fs.existsSync(userconfigPath)) {
+                fs.mkdirSync(userconfigPath, { recursive: true });
+            }
+            fs.writeFileSync(this.balanceFilePath, balance.toString(), 'utf-8');
+            if (this.balanceMessageService) {
+                this.balanceMessageService.emitUpdate(this.userId, balance);
+            }
+        }
+        catch (error) {
+            console.error(`Error saving balance for user ${this.userId}:`, error);
+            throw error;
+        }
+    }
+    saveMarkup(markup) {
+        try {
+            const commonConfigPath = this.configService.getCommonConfigDir();
+            if (!fs.existsSync(commonConfigPath)) {
+                fs.mkdirSync(commonConfigPath, { recursive: true });
+            }
+            fs.writeFileSync(this.markupFilePath, markup.toString(), 'utf-8');
+        }
+        catch (error) {
+            console.error(`Error saving markup:`, error);
+            throw error;
+        }
+    }
+}
+exports.BalanceService = BalanceService;

package/dist/app/stripe.controller.d.ts

@@ -0,0 +1,31 @@
+import { RawBodyRequest } from '@nestjs/common';
+import { StripeService } from './stripe.service';
+import { UserServiceManager } from './user-service-manager';
+import type { Request as ExpressRequest } from 'express';
+import { CreatePaymentIntentRequest, CreatePaymentIntentResponse, TransactionHistoryResponse, CreateCheckoutSessionRequest, CreateCheckoutSessionResponse } from '@shared/types/app.types';
+export declare class StripeController {
+    private readonly stripeService;
+    private readonly userServiceManager;
+    constructor(stripeService: StripeService, userServiceManager: UserServiceManager);
+    createPaymentIntent(req: ExpressRequest & {
+        user: {
+            userId: string;
+        };
+    }, body: CreatePaymentIntentRequest): Promise<CreatePaymentIntentResponse>;
+    createCheckoutSession(req: ExpressRequest & {
+        user: {
+            userId: string;
+        };
+    }, body: CreateCheckoutSessionRequest): Promise<CreateCheckoutSessionResponse>;
+    getStripeConfig(): Promise<{
+        publishableKey: string;
+    }>;
+    handleWebhook(req: RawBodyRequest<ExpressRequest>, signature: string): Promise<{
+        received: boolean;
+    }>;
+    getTransactionHistory(req: ExpressRequest & {
+        user: {
+            userId: string;
+        };
+    }, limit?: string, offset?: string): Promise<TransactionHistoryResponse>;
+}

package/dist/app/stripe.controller.js

@@ -0,0 +1,150 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripeController = void 0;
+const common_1 = require("@nestjs/common");
+const stripe_service_1 = require("./stripe.service");
+const user_service_manager_1 = require("./user-service-manager");
+const jwt_auth_guard_1 = require("../auth/jwt-auth.guard");
+const public_decorator_1 = require("../auth/public.decorator");
+const app_types_1 = require("@shared/types/app.types");
+let StripeController = class StripeController {
+    stripeService;
+    userServiceManager;
+    constructor(stripeService, userServiceManager) {
+        this.stripeService = stripeService;
+        this.userServiceManager = userServiceManager;
+    }
+    async createPaymentIntent(req, body) {
+        const userId = req.user.userId;
+        const { amount } = body;
+        const appService = this.userServiceManager.getAppService(userId);
+        const transactionService = appService.getTransactionService();
+        const result = await this.stripeService.createPaymentIntent(userId, amount, transactionService);
+        return result;
+    }
+    async createCheckoutSession(req, body) {
+        const userId = req.user.userId;
+        const { amount } = body;
+        const appService = this.userServiceManager.getAppService(userId);
+        const transactionService = appService.getTransactionService();
+        const result = await this.stripeService.createCheckoutSession(userId, amount, transactionService);
+        return result;
+    }
+    async getStripeConfig() {
+        return this.stripeService.getStripeConfig();
+    }
+    async handleWebhook(req, signature) {
+        console.log('[Stripe Webhook] Received webhook request');
+        if (!signature) {
+            console.error('[Stripe Webhook] Missing stripe-signature header');
+            throw new common_1.BadRequestException('Missing stripe-signature header');
+        }
+        const rawBody = req.rawBody;
+        if (!rawBody) {
+            console.error('[Stripe Webhook] Missing request body');
+            throw new common_1.BadRequestException('Missing request body');
+        }
+        console.log('[Stripe Webhook] Verifying webhook signature...');
+        const event = this.stripeService.verifyWebhookSignature(rawBody, signature);
+        console.log(`[Stripe Webhook] Event type: ${event.type}, Event ID: ${event.id}`);
+        switch (event.type) {
+            case 'payment_intent.succeeded': {
+                console.log('[Stripe Webhook] Matched payment_intent.succeeded case');
+                const paymentIntent = event.data.object;
+                const userId = paymentIntent.metadata.userId;
+                if (!userId) {
+                    console.error('Payment Intent missing userId in metadata');
+                    return { received: true };
+                }
+                const appService = this.userServiceManager.getAppService(userId);
+                await this.stripeService.handlePaymentIntentSucceeded(paymentIntent, appService);
+                break;
+            }
+            case 'payment_intent.payment_failed': {
+                console.log('[Stripe Webhook] Matched payment_intent.payment_failed case');
+                const paymentIntent = event.data.object;
+                const userId = paymentIntent.metadata.userId;
+                if (!userId) {
+                    console.error('[Stripe Webhook] Payment Intent missing userId in metadata');
+                    return { received: true };
+                }
+                const appService = this.userServiceManager.getAppService(userId);
+                await this.stripeService.handlePaymentIntentFailed(paymentIntent, appService);
+                break;
+            }
+            default:
+                console.log(`[Stripe Webhook] Unhandled event type: ${event.type}`);
+        }
+        console.log('[Stripe Webhook] Webhook processed successfully');
+        return { received: true };
+    }
+    async getTransactionHistory(req, limit, offset) {
+        const userId = req.user.userId;
+        const parsedLimit = limit ? parseInt(limit, 10) : 50;
+        const parsedOffset = offset ? parseInt(offset, 10) : 0;
+        const appService = this.userServiceManager.getAppService(userId);
+        const transactionService = appService.getTransactionService();
+        const result = await transactionService.getTransactions(parsedLimit, parsedOffset);
+        return result;
+    }
+};
+exports.StripeController = StripeController;
+__decorate([
+    (0, common_1.Post)('create-payment-intent'),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, typeof (_a = typeof app_types_1.CreatePaymentIntentRequest !== "undefined" && app_types_1.CreatePaymentIntentRequest) === "function" ? _a : Object]),
+    __metadata("design:returntype", Promise)
+], StripeController.prototype, "createPaymentIntent", null);
+__decorate([
+    (0, common_1.Post)('create-checkout-session'),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, typeof (_b = typeof app_types_1.CreateCheckoutSessionRequest !== "undefined" && app_types_1.CreateCheckoutSessionRequest) === "function" ? _b : Object]),
+    __metadata("design:returntype", Promise)
+], StripeController.prototype, "createCheckoutSession", null);
+__decorate([
+    (0, common_1.Get)('config'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], StripeController.prototype, "getStripeConfig", null);
+__decorate([
+    (0, public_decorator_1.Public)(),
+    (0, common_1.Post)('webhook'),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Headers)('stripe-signature')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], StripeController.prototype, "handleWebhook", null);
+__decorate([
+    (0, common_1.Get)('transactions/history'),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Query)('limit')),
+    __param(2, (0, common_1.Query)('offset')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, String]),
+    __metadata("design:returntype", Promise)
+], StripeController.prototype, "getTransactionHistory", null);
+exports.StripeController = StripeController = __decorate([
+    (0, common_1.Controller)('api/stripe'),
+    (0, common_1.UseGuards)(jwt_auth_guard_1.JwtAuthGuard),
+    __metadata("design:paramtypes", [stripe_service_1.StripeService,
+        user_service_manager_1.UserServiceManager])
+], StripeController);

package/dist/app/stripe.module.d.ts

@@ -0,0 +1,2 @@
+export declare class StripeModule {
+}

package/dist/app/stripe.module.js

@@ -0,0 +1,22 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripeModule = void 0;
+const common_1 = require("@nestjs/common");
+const stripe_service_1 = require("./stripe.service");
+const stripe_controller_1 = require("./stripe.controller");
+let StripeModule = class StripeModule {
+};
+exports.StripeModule = StripeModule;
+exports.StripeModule = StripeModule = __decorate([
+    (0, common_1.Module)({
+        providers: [stripe_service_1.StripeService],
+        controllers: [stripe_controller_1.StripeController],
+        exports: [stripe_service_1.StripeService],
+    })
+], StripeModule);

package/dist/app/stripe.service.d.ts

@@ -0,0 +1,28 @@
+import Stripe from 'stripe';
+import { TransactionService } from './transaction.service';
+import { AppService } from '../app.service';
+type StripeInstance = ReturnType<typeof Stripe>;
+type StripeEvent = ReturnType<StripeInstance['webhooks']['constructEvent']>;
+type StripePaymentIntent = Awaited<ReturnType<StripeInstance['paymentIntents']['retrieve']>>;
+export declare class StripeService {
+    private stripe;
+    private minPaymentAmount;
+    private maxPaymentAmount;
+    private publishableKey;
+    private webhookSecret;
+    constructor();
+    createPaymentIntent(userId: string, amount: number, transactionService: TransactionService): Promise<{
+        clientSecret: string;
+        publishableKey: string;
+    }>;
+    createCheckoutSession(userId: string, amount: number, transactionService: TransactionService): Promise<{
+        url: string;
+    }>;
+    getStripeConfig(): {
+        publishableKey: string;
+    };
+    verifyWebhookSignature(rawBody: Buffer | string, signature: string): StripeEvent;
+    handlePaymentIntentSucceeded(paymentIntent: StripePaymentIntent, appService: AppService): Promise<void>;
+    handlePaymentIntentFailed(paymentIntent: StripePaymentIntent, appService: AppService): Promise<void>;
+}
+export {};

package/dist/app/stripe.service.js

@@ -0,0 +1,198 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripeService = void 0;
+const common_1 = require("@nestjs/common");
+const stripe_1 = __importDefault(require("stripe"));
+let StripeService = class StripeService {
+    stripe;
+    minPaymentAmount;
+    maxPaymentAmount;
+    publishableKey;
+    webhookSecret;
+    constructor() {
+        if (!process.env.STRIPE_SECRET_KEY) {
+            throw new Error('STRIPE_SECRET_KEY environment variable is required');
+        }
+        if (!process.env.STRIPE_PUBLISHABLE_KEY) {
+            throw new Error('STRIPE_PUBLISHABLE_KEY environment variable is required');
+        }
+        if (!process.env.STRIPE_WEBHOOK_SECRET) {
+            throw new Error('STRIPE_WEBHOOK_SECRET environment variable is required');
+        }
+        this.stripe = (0, stripe_1.default)(process.env.STRIPE_SECRET_KEY, {
+            apiVersion: '2026-03-25.dahlia',
+        });
+        this.publishableKey = process.env.STRIPE_PUBLISHABLE_KEY;
+        this.webhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
+        this.minPaymentAmount = parseFloat(process.env.MIN_PAYMENT_AMOUNT || '5.00');
+        this.maxPaymentAmount = parseFloat(process.env.MAX_PAYMENT_AMOUNT || '500.00');
+    }
+    async createPaymentIntent(userId, amount, transactionService) {
+        if (!amount || amount <= 0) {
+            throw new common_1.BadRequestException('Amount must be greater than 0');
+        }
+        if (amount < this.minPaymentAmount) {
+            throw new common_1.BadRequestException(`Amount must be at least $${this.minPaymentAmount.toFixed(2)}`);
+        }
+        if (amount > this.maxPaymentAmount) {
+            throw new common_1.BadRequestException(`Amount must not exceed $${this.maxPaymentAmount.toFixed(2)}`);
+        }
+        try {
+            const amountInCents = Math.round(amount * 100);
+            const paymentIntent = await this.stripe.paymentIntents.create({
+                amount: amountInCents,
+                currency: 'usd',
+                metadata: {
+                    userId,
+                },
+                automatic_payment_methods: {
+                    enabled: true,
+                },
+            });
+            await transactionService.recordTransaction(amount, paymentIntent.id, 'pending');
+            return {
+                clientSecret: paymentIntent.client_secret,
+                publishableKey: this.publishableKey,
+            };
+        }
+        catch (error) {
+            console.error('Error creating Payment Intent:', error);
+            throw new common_1.InternalServerErrorException('Failed to create payment intent');
+        }
+    }
+    async createCheckoutSession(userId, amount, transactionService) {
+        if (!amount || amount <= 0) {
+            throw new common_1.BadRequestException('Amount must be greater than 0');
+        }
+        if (amount < this.minPaymentAmount) {
+            throw new common_1.BadRequestException(`Amount must be at least $${this.minPaymentAmount.toFixed(2)}`);
+        }
+        if (amount > this.maxPaymentAmount) {
+            throw new common_1.BadRequestException(`Amount must not exceed $${this.maxPaymentAmount.toFixed(2)}`);
+        }
+        try {
+            const amountInCents = Math.round(amount * 100);
+            const session = await this.stripe.checkout.sessions.create({
+                payment_method_types: ['card'],
+                line_items: [
+                    {
+                        price_data: {
+                            currency: 'usd',
+                            product_data: {
+                                name: 'Briyah Credits',
+                                description: `Add $${amount.toFixed(2)} to your Briyah balance`,
+                            },
+                            unit_amount: amountInCents,
+                        },
+                        quantity: 1,
+                    },
+                ],
+                mode: 'payment',
+                success_url: `${process.env.WEB_URL || 'http://localhost:5173'}/payment-success?session_id={CHECKOUT_SESSION_ID}`,
+                cancel_url: `${process.env.WEB_URL || 'http://localhost:5173'}/payment-cancelled`,
+                metadata: {
+                    userId,
+                },
+                payment_intent_data: {
+                    metadata: {
+                        userId,
+                    },
+                },
+            });
+            if (session.payment_intent) {
+                await transactionService.recordTransaction(amount, session.payment_intent, 'pending');
+            }
+            return {
+                url: session.url,
+            };
+        }
+        catch (error) {
+            console.error('Error creating Checkout Session:', error);
+            throw new common_1.InternalServerErrorException('Failed to create checkout session');
+        }
+    }
+    getStripeConfig() {
+        return {
+            publishableKey: this.publishableKey,
+        };
+    }
+    verifyWebhookSignature(rawBody, signature) {
+        try {
+            return this.stripe.webhooks.constructEvent(rawBody, signature, this.webhookSecret);
+        }
+        catch (error) {
+            console.error('Webhook signature verification failed:', error);
+            throw new common_1.BadRequestException('Invalid webhook signature');
+        }
+    }
+    async handlePaymentIntentSucceeded(paymentIntent, appService) {
+        try {
+            const userId = paymentIntent.metadata.userId;
+            console.log(`[Stripe Webhook] Processing payment_intent.succeeded for user ${userId}, payment ${paymentIntent.id}`);
+            if (!userId) {
+                console.error('Payment Intent missing userId in metadata:', paymentIntent.id);
+                return;
+            }
+            const amount = paymentIntent.amount / 100;
+            console.log(`[Stripe Webhook] Amount: $${amount.toFixed(2)}`);
+            const transactionService = appService.getTransactionService();
+            const existingTransaction = await transactionService.getTransactionByPaymentIntent(paymentIntent.id);
+            console.log(`[Stripe Webhook] Existing transaction:`, existingTransaction);
+            if (existingTransaction?.status === 'succeeded') {
+                console.log(`Transaction ${paymentIntent.id} already processed, skipping`);
+                return;
+            }
+            const balanceBefore = await appService.getBalance();
+            console.log(`[Stripe Webhook] Balance before: $${balanceBefore.toFixed(2)}`);
+            console.log(`[Stripe Webhook] Adding $${amount.toFixed(2)} to balance`);
+            await appService.addBalance(amount);
+            const balanceAfter = await appService.getBalance();
+            console.log(`[Stripe Webhook] Balance after: $${balanceAfter.toFixed(2)}`);
+            console.log(`[Stripe Webhook] Updating transaction status to 'succeeded'`);
+            await transactionService.updateTransactionStatus(paymentIntent.id, 'succeeded');
+            console.log(`[Stripe Webhook] Checking for paused stories to resume...`);
+            const resumedCount = await appService.resumePausedStories();
+            if (resumedCount > 0) {
+                console.log(`[Stripe Webhook] Resumed ${resumedCount} paused story/stories`);
+            }
+            console.log(`[Stripe Webhook] Payment succeeded: $${amount.toFixed(2)} added to user ${userId} (balance: ${balanceBefore.toFixed(2)} → ${balanceAfter.toFixed(2)})`);
+        }
+        catch (error) {
+            console.error('[Stripe Webhook] Error handling payment success:', error);
+            throw error;
+        }
+    }
+    async handlePaymentIntentFailed(paymentIntent, appService) {
+        try {
+            const userId = paymentIntent.metadata.userId;
+            if (!userId) {
+                console.error('Payment Intent missing userId in metadata:', paymentIntent.id);
+                return;
+            }
+            const transactionService = appService.getTransactionService();
+            await transactionService.updateTransactionStatus(paymentIntent.id, 'failed');
+            console.log(`Payment failed for user ${userId}: ${paymentIntent.id}`);
+        }
+        catch (error) {
+            console.error('Error handling payment failure:', error);
+            throw error;
+        }
+    }
+};
+exports.StripeService = StripeService;
+exports.StripeService = StripeService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], StripeService);

package/dist/app/transaction.service.d.ts

@@ -0,0 +1,15 @@
+import { ConfigurationService } from '../config/configuration.service';
+import { Transaction } from '@shared/types/app.types';
+export declare class TransactionService {
+    private userId;
+    private configService;
+    private transactionsDir;
+    constructor(userId: string, configService: ConfigurationService);
+    recordTransaction(amount: number, stripePaymentIntentId: string, status?: 'pending' | 'succeeded' | 'failed' | 'cancelled'): Promise<Transaction>;
+    updateTransactionStatus(paymentIntentId: string, status: 'pending' | 'succeeded' | 'failed' | 'cancelled'): Promise<void>;
+    getTransactionByPaymentIntent(paymentIntentId: string): Promise<Transaction | null>;
+    getTransactions(limit?: number, offset?: number): Promise<{
+        transactions: Transaction[];
+        total: number;
+    }>;
+}