@misterhomer1992/miit-bot-payment 1.1.6 → 2.0.4

package/src/modules/payments/webhook.types.ts

@@ -0,0 +1,38 @@
+import { WayForPayCallbackData, WayForPayWebhookResponse } from './wayforpay.types';
+
+/**
+ * Result of processing a webhook callback
+ */
+type WebhookProcessingResult = {
+    success: boolean;
+    response: WayForPayWebhookResponse;
+    error?: string;
+};
+
+/**
+ * Parameters for activating a subscription from webhook
+ */
+type ActivateSubscriptionParams = {
+    userId: string;
+    platform: string;
+    planId: string;
+    orderReference: string;
+};
+
+/**
+ * Interface for webhook handler service operations.
+ * Handles payment confirmation webhooks from WayForPay.
+ */
+interface IWebhookHandlerService {
+    /**
+     * Processes a payment confirmation webhook from WayForPay.
+     * Verifies signature, updates payment status, activates subscription,
+     * and initializes user token balance.
+     *
+     * @param callbackData - The callback data from WayForPay
+     * @returns Processing result with response to send back to WayForPay
+     */
+    processPaymentWebhook(callbackData: WayForPayCallbackData): Promise<WebhookProcessingResult>;
+}
+
+export type { WebhookProcessingResult, ActivateSubscriptionParams, IWebhookHandlerService };

package/src/modules/subscription/change.service.ts

@@ -0,0 +1,317 @@
+import moment from 'moment';
+import { Logger } from '../logger/types';
+import { SubscriptionService } from './service';
+import { SubscriptionPlanService } from '../subscriptionPlan/service';
+import { PaymentService } from '../payments/service';
+import type { ISubscriptionService, SubscriptionEntity, UpgradePreview, UpgradeResult } from './types';
+import type { ISubscriptionPlanService, SubscriptionPlanEntity } from '../subscriptionPlan/types';
+import type { IPaymentService } from '../payments/types';
+
+/**
+ * Error codes for subscription change operations
+ */
+export const SubscriptionChangeErrorCodes = {
+    NO_ACTIVE_SUBSCRIPTION: 'NO_ACTIVE_SUBSCRIPTION',
+    SUBSCRIPTION_EXPIRED: 'SUBSCRIPTION_EXPIRED',
+    SAME_PLAN: 'SAME_PLAN',
+    DOWNGRADE_NOT_ALLOWED: 'DOWNGRADE_NOT_ALLOWED',
+    UPGRADE_NOT_ALLOWED: 'UPGRADE_NOT_ALLOWED',
+    PLAN_NOT_FOUND: 'PLAN_NOT_FOUND',
+    CURRENCY_MISMATCH: 'CURRENCY_MISMATCH',
+    INVALID_UPGRADE_COST: 'INVALID_UPGRADE_COST',
+} as const;
+
+export type SubscriptionChangeErrorCode = (typeof SubscriptionChangeErrorCodes)[keyof typeof SubscriptionChangeErrorCodes];
+
+export class SubscriptionChangeError extends Error {
+    public readonly code: SubscriptionChangeErrorCode;
+
+    constructor(code: SubscriptionChangeErrorCode, message: string) {
+        super(message);
+        this.code = code;
+        this.name = 'SubscriptionChangeError';
+    }
+}
+
+/**
+ * Service for handling subscription upgrades and downgrades.
+ */
+export class SubscriptionChangeService {
+    private readonly logger: Logger;
+    private readonly subscriptionService: ISubscriptionService;
+    private readonly subscriptionPlanService: ISubscriptionPlanService;
+    private readonly paymentService: IPaymentService;
+
+    constructor({
+        logger,
+        subscriptionService,
+        subscriptionPlanService,
+        paymentService,
+    }: {
+        logger: Logger;
+        subscriptionService?: ISubscriptionService;
+        subscriptionPlanService?: ISubscriptionPlanService;
+        paymentService?: IPaymentService;
+    }) {
+        this.logger = logger;
+        this.subscriptionService = subscriptionService || new SubscriptionService({ logger });
+        this.subscriptionPlanService = subscriptionPlanService || new SubscriptionPlanService({ logger });
+        this.paymentService = paymentService || new PaymentService({ logger });
+    }
+
+    /**
+     * Preview upgrade cost without initiating payment.
+     * Calculates the remaining value of the current subscription and the cost to upgrade.
+     */
+    public async getUpgradePreview(params: {
+        userId: string;
+        platform: string;
+        newPlanId: string;
+    }): Promise<UpgradePreview> {
+        const { userId, platform, newPlanId } = params;
+
+        // Get active subscription
+        const subscription = await this.subscriptionService.getByUser({
+            userId,
+            platform,
+            status: 'active',
+        });
+
+        if (!subscription) {
+            throw new SubscriptionChangeError(
+                SubscriptionChangeErrorCodes.NO_ACTIVE_SUBSCRIPTION,
+                'No active subscription found for user',
+            );
+        }
+
+        // Check if subscription has expired
+        const now = moment.utc();
+        const expiresAt = moment.utc(subscription.expiresAt);
+        if (expiresAt.isBefore(now)) {
+            throw new SubscriptionChangeError(
+                SubscriptionChangeErrorCodes.SUBSCRIPTION_EXPIRED,
+                'Current subscription has expired',
+            );
+        }
+
+        // Get current and new plans
+        const [currentPlan, newPlan] = await Promise.all([
+            this.subscriptionPlanService.getById(subscription.planId),
+            this.subscriptionPlanService.getById(newPlanId),
+        ]);
+
+        if (!currentPlan) {
+            throw new SubscriptionChangeError(
+                SubscriptionChangeErrorCodes.PLAN_NOT_FOUND,
+                `Current plan not found: ${subscription.planId}`,
+            );
+        }
+
+        if (!newPlan) {
+            throw new SubscriptionChangeError(
+                SubscriptionChangeErrorCodes.PLAN_NOT_FOUND,
+                `New plan not found: ${newPlanId}`,
+            );
+        }
+
+        // Check if same plan
+        if (currentPlan.id === newPlan.id) {
+            throw new SubscriptionChangeError(
+                SubscriptionChangeErrorCodes.SAME_PLAN,
+                'Cannot upgrade to the same plan',
+            );
+        }
+
+        // Check currency match
+        if (currentPlan.currency !== newPlan.currency) {
+            throw new SubscriptionChangeError(
+                SubscriptionChangeErrorCodes.CURRENCY_MISMATCH,
+                'Cannot change between plans with different currencies',
+            );
+        }
+
+        // Check if this is actually an upgrade (new plan must be more expensive)
+        if (newPlan.amount <= currentPlan.amount) {
+            throw new SubscriptionChangeError(
+                SubscriptionChangeErrorCodes.DOWNGRADE_NOT_ALLOWED,
+                'New plan must be more expensive than current plan. Use downgrade instead.',
+            );
+        }
+
+        // Calculate remaining value
+        const remainingValue = this.calculateRemainingValue(subscription, currentPlan);
+        const remainingDays = this.calculateRemainingDays(subscription);
+
+        // Calculate upgrade cost
+        const upgradeCost = Math.max(0, Math.round((newPlan.amount - remainingValue) * 100) / 100);
+
+        // Validate upgrade cost
+        if (upgradeCost <= 0) {
+            throw new SubscriptionChangeError(
+                SubscriptionChangeErrorCodes.INVALID_UPGRADE_COST,
+                'Upgrade cost must be greater than 0',
+            );
+        }
+
+        return {
+            currentPlan,
+            newPlan,
+            remainingDays,
+            remainingValue: Math.round(remainingValue * 100) / 100,
+            upgradeCost,
+            currency: currentPlan.currency,
+        };
+    }
+
+    /**
+     * Initiate upgrade - creates payment for the difference.
+     * Creates a recurring payment for the new plan.
+     */
+    public async initiateUpgrade(params: {
+        userId: string;
+        platform: string;
+        newPlanId: string;
+        productName: string;
+        language?: string;
+    }): Promise<UpgradeResult> {
+        const { userId, platform, newPlanId, productName, language } = params;
+
+        // Get upgrade preview (validates everything)
+        const preview = await this.getUpgradePreview({ userId, platform, newPlanId });
+
+        this.logger.info({
+            message: 'Initiating subscription upgrade',
+            payload: {
+                userId,
+                platform,
+                currentPlanId: preview.currentPlan.id,
+                newPlanId: preview.newPlan.id,
+                upgradeCost: preview.upgradeCost,
+                currency: preview.currency,
+            },
+        });
+
+        // Create upgrade payment intent
+        const payment = await this.paymentService.createUpgradePaymentIntent({
+            userId,
+            platform,
+            currentPlanId: preview.currentPlan.id,
+            newPlanId: preview.newPlan.id,
+            productName,
+            upgradeCost: preview.upgradeCost,
+            currency: preview.currency,
+            regularMode: preview.newPlan.regularMode,
+            regularCount: preview.newPlan.count,
+            language,
+        });
+
+        this.logger.info({
+            message: 'Upgrade payment intent created',
+            payload: {
+                userId,
+                platform,
+                paymentId: payment.id,
+                orderReference: payment.orderReference,
+            },
+        });
+
+        return {
+            payment,
+            paymentUrl: payment.paymentLink,
+        };
+    }
+
+    /**
+     * Simple downgrade - just expire current subscription.
+     * User will need to purchase the new subscription themselves.
+     */
+    public async downgrade(params: {
+        userId: string;
+        platform: string;
+    }): Promise<void> {
+        const { userId, platform } = params;
+
+        // Get active subscription
+        const subscription = await this.subscriptionService.getByUser({
+            userId,
+            platform,
+            status: 'active',
+        });
+
+        if (!subscription) {
+            throw new SubscriptionChangeError(
+                SubscriptionChangeErrorCodes.NO_ACTIVE_SUBSCRIPTION,
+                'No active subscription found for user',
+            );
+        }
+
+        this.logger.info({
+            message: 'Downgrading subscription (setting to expired)',
+            payload: {
+                userId,
+                platform,
+                subscriptionId: subscription.id,
+                planId: subscription.planId,
+            },
+        });
+
+        // Set subscription status to expired
+        await this.subscriptionService.updateFieldsById({
+            subscriptionId: subscription.id,
+            fields: [['status', 'expired']],
+        });
+
+        this.logger.info({
+            message: 'Subscription downgraded successfully',
+            payload: {
+                userId,
+                platform,
+                subscriptionId: subscription.id,
+            },
+        });
+    }
+
+    /**
+     * Calculate remaining value of a subscription.
+     * Formula: remainingDays * dailyRate
+     * Where dailyRate = plan.amount / totalPeriodDays
+     */
+    private calculateRemainingValue(
+        subscription: SubscriptionEntity,
+        plan: SubscriptionPlanEntity,
+    ): number {
+        const remainingDays = this.calculateRemainingDays(subscription);
+        const totalPeriodDays = this.getPeriodDays(plan.regularMode, plan.count);
+        const dailyRate = plan.amount / totalPeriodDays;
+
+        return remainingDays * dailyRate;
+    }
+
+    /**
+     * Calculate remaining days until subscription expires.
+     */
+    private calculateRemainingDays(subscription: SubscriptionEntity): number {
+        const now = moment.utc();
+        const expiresAt = moment.utc(subscription.expiresAt);
+        const remainingMs = expiresAt.diff(now);
+
+        // Convert to days (fractional)
+        return Math.max(0, remainingMs / (1000 * 60 * 60 * 24));
+    }
+
+    /**
+     * Get the number of days in a subscription period.
+     */
+    private getPeriodDays(regularMode: 'daily' | 'monthly' | 'yearly', count: number): number {
+        switch (regularMode) {
+            case 'daily':
+                return count;
+            case 'monthly':
+                return count * 30; // Approximate
+            case 'yearly':
+                return count * 365; // Approximate
+            default:
+                return count * 30;
+        }
+    }
+}

package/src/modules/subscription/const.ts

@@ -0,0 +1,9 @@
+import { SubscriptionEntity } from './types';
+
+const DEFAULT_SUBSCRIPTION_ENTITY: Partial<SubscriptionEntity> = {
+    status: 'active',
+    platform: 'telegram',
+    provider: 'wayforpay',
+};
+
+export { DEFAULT_SUBSCRIPTION_ENTITY };

package/src/modules/subscription/index.ts

@@ -0,0 +1,5 @@
+export * from './utils';
+export * from './types';
+export * from './service';
+export * from './status-check.handler';
+export * from './change.service';

package/src/modules/subscription/repository.ts

@@ -0,0 +1,277 @@
+import { FieldValue, Firestore, getFirestore, Query, QueryDocumentSnapshot } from 'firebase-admin/firestore';
+import { SubscriptionEntity, SubscriptionFieldPath, ISubscriptionRepository } from './types';
+import { isUndefined } from '../../utils';
+
+export type UpdateDBSubscriptionFields = [
+    SubscriptionFieldPath,
+    FieldValue | string | number | boolean | Date | [] | {},
+][];
+
+export class SubscriptionRepository implements ISubscriptionRepository {
+    private readonly db: Firestore;
+    private readonly collectionName = 'subscriptions';
+
+    constructor({ db }: { db?: Firestore } = {}) {
+        this.db = db || getFirestore();
+    }
+
+    public async getByUser(params: {
+        userId: string;
+        platform: string;
+        status?: SubscriptionEntity['status'] | SubscriptionEntity['status'][];
+    }): Promise<SubscriptionEntity | null> {
+        const { userId, platform } = params;
+
+        let query = this.db
+            .collection(this.collectionName)
+            .where('platform', '==', platform)
+            .where('userId', '==', userId);
+
+        if (!isUndefined(params.status)) {
+            // Handle status filter
+            if (Array.isArray(params.status)) {
+                // Multiple statuses - use 'in' operator
+                query = query.where('status', 'in', params.status);
+            } else {
+                // Single status - use '==' operator
+                query = query.where('status', '==', params.status);
+            }
+        }
+
+        const querySnapshot = await query.limit(1).get();
+
+        if (querySnapshot.empty) {
+            return null;
+        }
+
+        const doc = querySnapshot.docs[0];
+        return this.mapDocumentToEntity(doc);
+    }
+
+    public async getByStatus(params: {
+        status: SubscriptionEntity['status'] | SubscriptionEntity['status'][];
+    }): Promise<SubscriptionEntity[]> {
+        const { status } = params;
+
+        let query: Query;
+
+        if (Array.isArray(status)) {
+            query = await this.db.collection(this.collectionName).where('status', 'in', status);
+        } else {
+            query = await this.db.collection(this.collectionName).where('status', '==', status);
+        }
+
+        const querySnapshot = await query.get();
+
+        if (querySnapshot.empty) {
+            return [];
+        }
+
+        return querySnapshot.docs.map((doc) => this.mapDocumentToEntity(doc));
+    }
+
+    public async create(params: {
+        userId: string;
+        platform: string;
+        planId: string;
+        expiresAt: string;
+        startedAt: string;
+    }): Promise<SubscriptionEntity> {
+        const { userId, platform, planId, expiresAt, startedAt } = params;
+
+        const docRef = this.db.collection(this.collectionName).doc();
+
+        const subscriptionEntity: SubscriptionEntity = {
+            id: docRef.id,
+            userId,
+            platform,
+            planId,
+            expiresAt,
+            startedAt,
+            status: 'active',
+            provider: 'wayforpay',
+        };
+
+        docRef.set(subscriptionEntity);
+
+        return subscriptionEntity;
+    }
+
+    public async updateFieldsByUserId(params: {
+        userId: string;
+        platform: string;
+        fields: UpdateDBSubscriptionFields;
+    }): Promise<void> {
+        const { userId, platform, fields } = params;
+
+        const updateObject = this.buildUpdateObject(fields);
+
+        const querySnapshot = await this.db
+            .collection(this.collectionName)
+            .where('platform', '==', platform)
+            .where('userId', '==', userId)
+            .limit(1)
+            .get();
+
+        if (querySnapshot.empty) {
+            throw new Error(`Subscription not found for userId: ${userId}`);
+        }
+
+        await querySnapshot.docs[0].ref.update(updateObject);
+    }
+
+    public async getExpiredActiveSubscriptions(): Promise<SubscriptionEntity[]> {
+        const now = new Date().toISOString();
+
+        const querySnapshot = await this.db
+            .collection(this.collectionName)
+            .where('status', '==', 'active')
+            .where('expiresAt', '<', now)
+            .get();
+
+        if (querySnapshot.empty) {
+            return [];
+        }
+
+        return querySnapshot.docs.map((doc) => this.mapDocumentToEntity(doc));
+    }
+
+    public async updateFieldsById(params: {
+        subscriptionId: string;
+        fields: UpdateDBSubscriptionFields;
+    }): Promise<void> {
+        const { subscriptionId, fields } = params;
+
+        const updateObject = this.buildUpdateObject(fields);
+
+        await this.db.collection(this.collectionName).doc(subscriptionId).update(updateObject);
+    }
+
+    private mapDocumentToEntity(doc: QueryDocumentSnapshot): SubscriptionEntity {
+        return {
+            id: doc.id,
+            ...doc.data(),
+        } as SubscriptionEntity;
+    }
+
+    public async activateSubscription(params: Omit<SubscriptionEntity, 'id' | 'status'>): Promise<void> {
+        const { userId, platform } = params;
+        return await this.db.runTransaction(async (tx) => {
+            // Get user document
+            const userSnapshot = await tx.get(this.db.collection(`platform/${platform}/users`).doc(userId));
+
+            if (!userSnapshot.exists) {
+                throw new Error(`User not found: ${userId}`);
+            }
+
+            const docRef = this.db.collection(this.collectionName).doc();
+            const newSubscription: SubscriptionEntity = {
+                ...params,
+                id: docRef.id,
+                status: 'active',
+            };
+
+            await tx.create(docRef, newSubscription);
+
+            // Update user document
+            await tx.update(userSnapshot.ref, {
+                'subscription.isActive': true,
+                'subscription.isTrial': false,
+            });
+        });
+    }
+
+    public async deactivateSubscription({ id }: Pick<SubscriptionEntity, 'id'>): Promise<void> {
+        return await this.db.runTransaction(async (tx) => {
+            const subscriptionSnapshot = await tx.get(this.db.collection(this.collectionName).doc(id));
+
+            if (!subscriptionSnapshot.exists) {
+                throw new Error(`Subscription not found for id: ${id}`);
+            }
+
+            const subscription = subscriptionSnapshot.data() as SubscriptionEntity;
+            const userSnapshot = await tx.get(
+                this.db.collection(`platform/${subscription.platform}/users`).doc(subscription.userId),
+            );
+
+            if (!userSnapshot.exists) {
+                throw new Error(`User not found: ${subscription.userId}; platform: ${subscription.platform}`);
+            }
+
+            const newSubscriptionData: Pick<SubscriptionEntity, 'status'> = {
+                status: 'expired',
+            };
+
+            await tx.update(subscriptionSnapshot.ref, newSubscriptionData);
+            await tx.update(userSnapshot.ref, {
+                'subscription.isActive': false,
+            });
+        });
+    }
+
+    public async cancelSubscription({ id }: Pick<SubscriptionEntity, 'id'>): Promise<void> {
+        return await this.db.runTransaction(async (tx) => {
+            const subscriptionSnapshot = await tx.get(this.db.collection(this.collectionName).doc(id));
+
+            if (!subscriptionSnapshot.exists) {
+                throw new Error(`Subscription not found for id: ${id}`);
+            }
+
+            const newSubscriptionData: Pick<SubscriptionEntity, 'status'> = {
+                status: 'cancelled',
+            };
+
+            await tx.update(subscriptionSnapshot.ref, newSubscriptionData);
+        });
+    }
+
+    public async renewSubscription(
+        params: Pick<SubscriptionEntity, 'userId' | 'platform' | 'expiresAt'>,
+    ): Promise<void> {
+        const { userId, platform } = params;
+        return await this.db.runTransaction(async (tx) => {
+            // Get user document
+            const userSnapshot = await tx.get(this.db.collection(`platform/${platform}/users`).doc(userId));
+            // Get subscription document
+            const subscriptionSnapshot = await tx.get(
+                this.db
+                    .collection(this.collectionName)
+                    .where('userId', '==', userId)
+                    .where('platform', '==', platform)
+                    .where('status', '==', 'active')
+                    .limit(1),
+            );
+
+            if (subscriptionSnapshot.empty) {
+                throw new Error(`Subscription not found for userId: ${userId}`);
+            }
+
+            if (!userSnapshot.exists) {
+                throw new Error(`User not found: ${userId}`);
+            }
+
+            const updateObject: Pick<SubscriptionEntity, 'status' | 'expiresAt'> = {
+                status: 'active',
+                expiresAt: params.expiresAt,
+            };
+
+            await tx.update(subscriptionSnapshot.docs[0].ref, updateObject);
+
+            // Update user document
+            await tx.update(userSnapshot.ref, {
+                'subscription.isActive': true,
+                'subscription.isTrial': false,
+            });
+        });
+    }
+
+    private buildUpdateObject(fields: UpdateDBSubscriptionFields): Record<string, any> {
+        const updateObject: Record<string, any> = {};
+
+        fields.forEach(([fieldPath, value]) => {
+            updateObject[fieldPath] = value;
+        });
+
+        return updateObject;
+    }
+}