@misterhomer1992/miit-bot-payment 1.1.7 → 2.0.4

package/src/modules/token/service.ts

@@ -0,0 +1,297 @@
+import moment from 'moment';
+import { Logger } from '../logger/types';
+import { TokenPackService } from '../tokenPack/service';
+import { PaymentService } from '../payments/service';
+import { ITokenPackService } from '../tokenPack/types';
+import { IPaymentService } from '../payments/types';
+import { DEFAULT_TOKEN_PACK_PLANS } from './const';
+import { createTokenPackPaymentAPI } from '../payments/api';
+import type {
+    TokenPackPlan,
+    PurchaseUrlResult,
+    CreatePurchaseUrlParams,
+    AddTokensParams,
+    DeductTokensParams,
+    TokenBalance,
+    ITokenService,
+} from './types';
+
+/**
+ * TokenService provides business logic for token pack purchases and balance management.
+ * Works independently of subscription status.
+ */
+export class TokenService implements ITokenService {
+    private readonly logger: Logger;
+    private readonly tokenPackService: ITokenPackService;
+    private readonly paymentService: IPaymentService;
+    private readonly tokenPackPlans: TokenPackPlan[];
+
+    constructor({
+        logger,
+        tokenPackService,
+        paymentService,
+        tokenPackPlans,
+    }: {
+        logger: Logger;
+        tokenPackService?: ITokenPackService;
+        paymentService?: IPaymentService;
+        tokenPackPlans?: TokenPackPlan[];
+    }) {
+        this.logger = logger;
+        this.tokenPackService = tokenPackService || new TokenPackService({ logger });
+        this.paymentService = paymentService || new PaymentService({ logger });
+        this.tokenPackPlans = tokenPackPlans || DEFAULT_TOKEN_PACK_PLANS;
+    }
+
+    /**
+     * Returns all available token pack plans for purchase.
+     */
+    public getAvailablePacks(): TokenPackPlan[] {
+        return this.tokenPackPlans.filter((plan) => plan.isActive);
+    }
+
+    /**
+     * Creates a one-time payment URL for purchasing a token pack.
+     */
+    public async createPurchaseUrl(params: CreatePurchaseUrlParams): Promise<PurchaseUrlResult | null> {
+        const { userId, platform, packId, language = 'UA', returnUrl } = params;
+
+        try {
+            // Find the token pack plan
+            const plan = this.tokenPackPlans.find((p) => p.id === packId);
+            if (!plan) {
+                this.logger.error({
+                    message: 'Token pack plan not found',
+                    payload: { packId },
+                });
+                return null;
+            }
+
+            if (!plan.isActive) {
+                this.logger.error({
+                    message: 'Token pack plan is not active',
+                    payload: { packId },
+                });
+                return null;
+            }
+
+            // Create one-time payment URL via WayForPay API
+            // Uses the v2 order reference format for token packs (tkn type)
+            const paymentResult = await createTokenPackPaymentAPI({
+                userId,
+                platform,
+                productName: `Token Pack - ${plan.tokens} tokens`,
+                productPrice: plan.amount,
+                packId,
+                currency: plan.currency,
+                language,
+                returnUrl,
+            });
+
+            if (!paymentResult) {
+                this.logger.error({
+                    message: 'Failed to generate payment URL for token pack',
+                    payload: { userId, platform, packId },
+                });
+                return null;
+            }
+
+            // Create payment record in database
+            await this.paymentService.create({
+                orderReference: paymentResult.orderReference,
+                userId,
+                status: 'pending',
+                paymentLink: paymentResult.url,
+                planId: packId,
+                paymentType: 'token_pack',
+                amount: plan.amount,
+                currency: plan.currency,
+                createdAt: moment.utc().toISOString(),
+                platform,
+                provider: 'wayforpay',
+            });
+
+            this.logger.info({
+                message: 'Token pack purchase URL created',
+                payload: {
+                    userId,
+                    platform,
+                    packId,
+                    orderReference: paymentResult.orderReference,
+                },
+            });
+
+            return {
+                url: paymentResult.url,
+                orderReference: paymentResult.orderReference,
+            };
+        } catch (error) {
+            this.logger.error({
+                message: 'Error creating token pack purchase URL',
+                payload: {
+                    userId,
+                    platform,
+                    packId,
+                    error: JSON.stringify(error),
+                },
+            });
+            return null;
+        }
+    }
+
+    /**
+     * Adds tokens to a user's balance by creating a new token pack.
+     * Called after successful payment confirmation.
+     */
+    public async addTokensToUser(params: AddTokensParams): Promise<void> {
+        const { userId, platform, packId, tokens } = params;
+
+        try {
+            await this.tokenPackService.create({
+                userId,
+                platform,
+                packId,
+                tokens,
+                purchasedAt: moment.utc().toISOString(),
+                provider: 'wayforpay',
+            });
+
+            this.logger.info({
+                message: 'Tokens added to user balance',
+                payload: {
+                    userId,
+                    platform,
+                    packId,
+                    tokens,
+                },
+            });
+        } catch (error) {
+            this.logger.error({
+                message: 'Error adding tokens to user balance',
+                payload: {
+                    userId,
+                    platform,
+                    packId,
+                    tokens,
+                    error: JSON.stringify(error),
+                },
+            });
+            throw error;
+        }
+    }
+
+    /**
+     * Deducts tokens from a user's available balance.
+     * Deducts from oldest packs first (FIFO).
+     */
+    public async deductTokens(params: DeductTokensParams): Promise<void> {
+        const { userId, platform, amount } = params;
+
+        try {
+            // Get active token packs sorted by purchase date (oldest first)
+            const activePacks = await this.tokenPackService.getByUser({
+                userId,
+                platform,
+                status: 'active',
+            });
+
+            if (activePacks.length === 0) {
+                throw new Error(`No active token packs found for user ${userId}`);
+            }
+
+            // Sort by purchasedAt (oldest first) for FIFO deduction
+            const sortedPacks = activePacks.sort(
+                (a, b) => new Date(a.purchasedAt).getTime() - new Date(b.purchasedAt).getTime(),
+            );
+
+            // Calculate total available tokens
+            const totalAvailable = sortedPacks.reduce((sum, pack) => sum + pack.tokensRemaining, 0);
+
+            if (totalAvailable < amount) {
+                throw new Error(
+                    `Insufficient tokens. Required: ${amount}, Available: ${totalAvailable}`,
+                );
+            }
+
+            // Deduct tokens from packs (FIFO)
+            let remainingToDeduct = amount;
+
+            for (const pack of sortedPacks) {
+                if (remainingToDeduct <= 0) break;
+
+                const deductFromPack = Math.min(pack.tokensRemaining, remainingToDeduct);
+                await this.tokenPackService.deductTokens({
+                    id: pack.id,
+                    amount: deductFromPack,
+                });
+
+                remainingToDeduct -= deductFromPack;
+            }
+
+            this.logger.info({
+                message: 'Tokens deducted from user balance',
+                payload: {
+                    userId,
+                    platform,
+                    amount,
+                    remainingTotal: totalAvailable - amount,
+                },
+            });
+        } catch (error) {
+            this.logger.error({
+                message: 'Error deducting tokens from user balance',
+                payload: {
+                    userId,
+                    platform,
+                    amount,
+                    error: JSON.stringify(error),
+                },
+            });
+            throw error;
+        }
+    }
+
+    /**
+     * Gets the current token balance for a user.
+     */
+    public async getBalance(params: { userId: string; platform: string }): Promise<TokenBalance> {
+        const { userId, platform } = params;
+
+        try {
+            const activePacks = await this.tokenPackService.getByUser({
+                userId,
+                platform,
+                status: 'active',
+            });
+
+            const available = activePacks.reduce((sum, pack) => sum + pack.tokensRemaining, 0);
+
+            const packs = activePacks.map((pack) => ({
+                id: pack.id,
+                packId: pack.packId,
+                tokensRemaining: pack.tokensRemaining,
+                purchasedAt: pack.purchasedAt,
+            }));
+
+            return {
+                available,
+                packs,
+            };
+        } catch (error) {
+            this.logger.error({
+                message: 'Error getting token balance',
+                payload: {
+                    userId,
+                    platform,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            // Return empty balance on error
+            return {
+                available: 0,
+                packs: [],
+            };
+        }
+    }
+}

package/src/modules/token/types.ts

@@ -0,0 +1,124 @@
+/**
+ * Token pack plan definition for one-time purchase.
+ */
+type TokenPackPlan = {
+    /** Unique identifier for the token pack plan */
+    id: string;
+    /** Translation key for the pack title */
+    titleCode: string;
+    /** Translation key for the pack description */
+    descriptionCode: string;
+    /** Number of tokens in the pack */
+    tokens: number;
+    /** Price amount */
+    amount: number;
+    /** Currency for the price */
+    currency: 'UAH' | 'USD';
+    /** Whether this pack is currently available for purchase */
+    isActive: boolean;
+};
+
+/**
+ * Result of creating a purchase URL.
+ */
+type PurchaseUrlResult = {
+    /** The payment URL to redirect the user to */
+    url: string;
+    /** Unique order reference for tracking the payment */
+    orderReference: string;
+};
+
+/**
+ * Parameters for creating a token pack purchase URL.
+ */
+type CreatePurchaseUrlParams = {
+    userId: string;
+    platform: string;
+    packId: string;
+    language?: 'EN' | 'UA';
+    returnUrl?: string;
+};
+
+/**
+ * Parameters for adding tokens to a user's balance.
+ */
+type AddTokensParams = {
+    userId: string;
+    platform: string;
+    packId: string;
+    tokens: number;
+};
+
+/**
+ * Parameters for deducting tokens from a user's balance.
+ */
+type DeductTokensParams = {
+    userId: string;
+    platform: string;
+    amount: number;
+};
+
+/**
+ * Token balance information for a user.
+ */
+type TokenBalance = {
+    /** Total available tokens across all active packs */
+    available: number;
+    /** List of active token packs with remaining tokens */
+    packs: {
+        id: string;
+        packId: string;
+        tokensRemaining: number;
+        purchasedAt: string;
+    }[];
+};
+
+/**
+ * Interface for token service operations.
+ * Provides methods for token pack management and balance operations.
+ */
+interface ITokenService {
+    /**
+     * Returns all available token pack plans for purchase.
+     * @returns Array of active token pack plans
+     */
+    getAvailablePacks(): TokenPackPlan[];
+
+    /**
+     * Creates a one-time payment URL for purchasing a token pack.
+     * @param params - Purchase parameters
+     * @returns Promise resolving to payment URL and order reference
+     */
+    createPurchaseUrl(params: CreatePurchaseUrlParams): Promise<PurchaseUrlResult | null>;
+
+    /**
+     * Adds tokens to a user's balance by creating a new token pack.
+     * Called after successful payment confirmation.
+     * @param params - Token addition parameters
+     */
+    addTokensToUser(params: AddTokensParams): Promise<void>;
+
+    /**
+     * Deducts tokens from a user's available balance.
+     * Deducts from oldest packs first (FIFO).
+     * @param params - Deduction parameters
+     */
+    deductTokens(params: DeductTokensParams): Promise<void>;
+
+    /**
+     * Gets the current token balance for a user.
+     * @param params - User identification parameters
+     * @returns Token balance information
+     */
+    getBalance(params: { userId: string; platform: string }): Promise<TokenBalance>;
+}
+
+export type {
+    TokenPackPlan,
+    PurchaseUrlResult,
+    CreatePurchaseUrlParams,
+    AddTokensParams,
+    DeductTokensParams,
+    TokenBalance,
+    ITokenService,
+};

package/src/modules/tokenPack/const.ts

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

package/src/modules/tokenPack/index.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './service';
+export * from './repository';
+export * from './const';

package/src/modules/tokenPack/repository.ts

@@ -0,0 +1,144 @@
+import { FieldValue, Firestore, getFirestore, QueryDocumentSnapshot } from 'firebase-admin/firestore';
+import { TokenPackEntity, TokenPackFieldPath, ITokenPackRepository } from './types';
+import { isUndefined } from '../../utils';
+
+export type UpdateDBTokenPackFields = [
+    TokenPackFieldPath,
+    FieldValue | string | number | boolean | Date | [] | {},
+][];
+
+export class TokenPackRepository implements ITokenPackRepository {
+    private readonly db: Firestore;
+    private readonly collectionName = 'tokenPacks';
+
+    constructor({ db }: { db?: Firestore } = {}) {
+        this.db = db || getFirestore();
+    }
+
+    public async getById(id: string): Promise<TokenPackEntity | null> {
+        const doc = await this.db.collection(this.collectionName).doc(id).get();
+
+        if (!doc.exists) {
+            return null;
+        }
+
+        return this.mapDocumentToEntity(doc as QueryDocumentSnapshot);
+    }
+
+    public async getByUser(params: {
+        userId: string;
+        platform: string;
+        status?: TokenPackEntity['status'] | TokenPackEntity['status'][];
+    }): Promise<TokenPackEntity[]> {
+        const { userId, platform } = params;
+
+        let query = this.db
+            .collection(this.collectionName)
+            .where('platform', '==', platform)
+            .where('userId', '==', userId);
+
+        if (!isUndefined(params.status)) {
+            if (Array.isArray(params.status)) {
+                query = query.where('status', 'in', params.status);
+            } else {
+                query = query.where('status', '==', params.status);
+            }
+        }
+
+        const querySnapshot = await query.get();
+
+        if (querySnapshot.empty) {
+            return [];
+        }
+
+        return querySnapshot.docs.map((doc) => this.mapDocumentToEntity(doc));
+    }
+
+    public async create(
+        params: Omit<TokenPackEntity, 'id' | 'status' | 'tokensRemaining'>,
+    ): Promise<TokenPackEntity> {
+        const docRef = this.db.collection(this.collectionName).doc();
+
+        const tokenPackEntity: TokenPackEntity = {
+            ...params,
+            id: docRef.id,
+            status: 'active',
+            tokensRemaining: params.tokens,
+        };
+
+        await docRef.set(tokenPackEntity);
+
+        return tokenPackEntity;
+    }
+
+    public async updateFieldsById(params: { id: string; fields: UpdateDBTokenPackFields }): Promise<void> {
+        const { id, fields } = params;
+
+        const updateObject = this.buildUpdateObject(fields);
+
+        await this.db.collection(this.collectionName).doc(id).update(updateObject);
+    }
+
+    public async deductTokens(params: { id: string; amount: number }): Promise<void> {
+        const { id, amount } = params;
+
+        return await this.db.runTransaction(async (tx) => {
+            const docRef = this.db.collection(this.collectionName).doc(id);
+            const doc = await tx.get(docRef);
+
+            if (!doc.exists) {
+                throw new Error(`TokenPack not found: ${id}`);
+            }
+
+            const tokenPack = doc.data() as TokenPackEntity;
+            const newRemaining = tokenPack.tokensRemaining - amount;
+
+            if (newRemaining < 0) {
+                throw new Error(`Insufficient tokens in pack ${id}`);
+            }
+
+            const updateData: Partial<TokenPackEntity> = {
+                tokensRemaining: newRemaining,
+            };
+
+            if (newRemaining === 0) {
+                updateData.status = 'depleted';
+            }
+
+            await tx.update(docRef, updateData);
+        });
+    }
+
+    public async getExpiredActiveTokenPacks(): Promise<TokenPackEntity[]> {
+        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));
+    }
+
+    private mapDocumentToEntity(doc: QueryDocumentSnapshot): TokenPackEntity {
+        return {
+            id: doc.id,
+            ...doc.data(),
+        } as TokenPackEntity;
+    }
+
+    private buildUpdateObject(fields: UpdateDBTokenPackFields): Record<string, any> {
+        const updateObject: Record<string, any> = {};
+
+        fields.forEach(([fieldPath, value]) => {
+            updateObject[fieldPath] = value;
+        });
+
+        return updateObject;
+    }
+}

package/src/modules/tokenPack/service.ts

@@ -0,0 +1,119 @@
+import { Logger } from '../logger/types';
+import { TokenPackRepository, UpdateDBTokenPackFields } from './repository';
+import { TokenPackEntity, ITokenPackRepository, ITokenPackService } from './types';
+
+export class TokenPackService implements ITokenPackService {
+    private readonly logger: Logger;
+    private readonly repository: ITokenPackRepository;
+
+    constructor({
+        logger,
+        repository,
+    }: {
+        logger: Logger;
+        repository?: ITokenPackRepository;
+    }) {
+        this.logger = logger;
+        this.repository = repository || new TokenPackRepository();
+    }
+
+    public async getById(id: string): Promise<TokenPackEntity | null> {
+        try {
+            return await this.repository.getById(id);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in token pack service getById',
+                payload: {
+                    id,
+                    error: JSON.stringify(error),
+                },
+            });
+            return null;
+        }
+    }
+
+    public async getByUser(params: {
+        userId: string;
+        platform: string;
+        status?: TokenPackEntity['status'] | TokenPackEntity['status'][];
+    }): Promise<TokenPackEntity[]> {
+        try {
+            return await this.repository.getByUser(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in token pack service getByUser',
+                payload: {
+                    userId: params.userId,
+                    platform: params.platform,
+                    error: JSON.stringify(error),
+                },
+            });
+            return [];
+        }
+    }
+
+    public async create(
+        params: Omit<TokenPackEntity, 'id' | 'status' | 'tokensRemaining'>,
+    ): Promise<TokenPackEntity> {
+        try {
+            return await this.repository.create(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in token pack service create',
+                payload: {
+                    userId: params.userId,
+                    platform: params.platform,
+                    packId: params.packId,
+                    error: JSON.stringify(error),
+                },
+            });
+            throw error;
+        }
+    }
+
+    public async updateFieldsById(params: { id: string; fields: UpdateDBTokenPackFields }): Promise<void> {
+        try {
+            await this.repository.updateFieldsById(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in token pack service updateFieldsById',
+                payload: {
+                    id: params.id,
+                    fields: JSON.stringify(params.fields),
+                    error: JSON.stringify(error),
+                },
+            });
+            throw error;
+        }
+    }
+
+    public async deductTokens(params: { id: string; amount: number }): Promise<void> {
+        try {
+            await this.repository.deductTokens(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in token pack service deductTokens',
+                payload: {
+                    id: params.id,
+                    amount: params.amount,
+                    error: JSON.stringify(error),
+                },
+            });
+            throw error;
+        }
+    }
+
+    public async getExpiredActiveTokenPacks(): Promise<TokenPackEntity[]> {
+        try {
+            return await this.repository.getExpiredActiveTokenPacks();
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in token pack service getExpiredActiveTokenPacks',
+                payload: {
+                    error: JSON.stringify(error),
+                },
+            });
+            return [];
+        }
+    }
+}