@misterhomer1992/miit-bot-payment 1.1.6 → 2.0.4

package/src/modules/payments/index.ts

@@ -0,0 +1,14 @@
+export * from './repository';
+export * from './service';
+export * from './types';
+export * from './const';
+export * from './api';
+export * from './utils';
+export * from './wayforpay.service';
+export * from './wayforpay.types';
+export * from './webhook.service';
+export * from './webhook.types';
+export * from './webhook.handler';
+export * from './subscription-check-webhook.service';
+export * from './subscription-check-webhook.types';
+export * from './subscription-check-webhook.handler';

package/src/modules/payments/repository.ts

@@ -0,0 +1,125 @@
+import { FieldValue, Firestore, getFirestore, QueryDocumentSnapshot } from 'firebase-admin/firestore';
+import { PaymentEntity, PaymentFieldPath, IPaymentRepository } from './types';
+import { DEFAULT_PAYMENT_ENTITY } from './const';
+
+export type UpdateDBPaymentFields = [PaymentFieldPath, FieldValue | string | number | boolean | Date | [] | {}][];
+
+export class PaymentRepository implements IPaymentRepository {
+    private readonly db: Firestore;
+    private readonly collectionName = 'payments';
+
+    constructor({ db }: { db?: Firestore } = {}) {
+        this.db = db || getFirestore();
+    }
+
+    public async getByOrderReference(orderReference: string): Promise<PaymentEntity | null> {
+        const querySnapshot = await this.db
+            .collection(this.collectionName)
+            .where('orderReference', '==', orderReference)
+            .limit(1)
+            .get();
+
+        if (querySnapshot.empty) {
+            return null;
+        }
+
+        const doc = querySnapshot.docs[0];
+        return this.mapDocumentToEntity(doc);
+    }
+
+    public async getByUser(params: {
+        userId: string;
+        platform: string;
+        status?: PaymentEntity['status'];
+    }): Promise<PaymentEntity[]> {
+        const { userId, platform, status } = params;
+
+        let query = this.db
+            .collection(this.collectionName)
+            .where('platform', '==', platform)
+            .where('userId', '==', userId);
+
+        if (status) {
+            query = query.where('status', '==', status);
+        }
+
+        const querySnapshot = await query.get();
+
+        if (querySnapshot.empty) {
+            return [];
+        }
+
+        return querySnapshot.docs.map((doc) => this.mapDocumentToEntity(doc));
+    }
+
+    public async create(paymentData: Omit<PaymentEntity, 'id'>): Promise<PaymentEntity> {
+        const docRef = this.db.collection(this.collectionName).doc();
+
+        const paymentEntity = {
+            id: docRef.id,
+            ...DEFAULT_PAYMENT_ENTITY,
+            ...paymentData,
+        };
+
+        docRef.set(paymentEntity);
+
+        return paymentEntity;
+    }
+
+    public async updateFields({ fields, id }: { id: string; fields: UpdateDBPaymentFields }): Promise<void> {
+        const updateObject = this.buildUpdateObject(fields);
+
+        const querySnapshot = await this.db.collection(this.collectionName).doc(id).get();
+
+        if (!querySnapshot.exists) {
+            throw new Error(`Payment not found for id: ${id}`);
+        }
+
+        await querySnapshot.ref.update(updateObject);
+    }
+
+    public async getExpiredPendingPayments(
+        params: {
+            hoursOld?: number;
+        } = {},
+    ): Promise<PaymentEntity[]> {
+        const { hoursOld = 24 } = params;
+
+        const cutoffTime = this.calculateCutoffTime(hoursOld);
+
+        const querySnapshot = await this.db
+            .collection(this.collectionName)
+            .where('status', '==', 'pending')
+            .where('createdAt', '<', cutoffTime.toISOString())
+            .get();
+
+        if (querySnapshot.empty) {
+            return [];
+        }
+
+        return querySnapshot.docs.map((doc) => this.mapDocumentToEntity(doc));
+    }
+
+    private mapDocumentToEntity(doc: QueryDocumentSnapshot): PaymentEntity {
+        return {
+            id: doc.id,
+            ...doc.data(),
+        } as PaymentEntity;
+    }
+
+    private buildUpdateObject(fields: UpdateDBPaymentFields): Record<string, any> {
+        const updateObject: Record<string, any> = {};
+
+        fields.forEach(([fieldPath, value]) => {
+            updateObject[fieldPath] = value;
+        });
+
+        return updateObject;
+    }
+
+    private calculateCutoffTime(hoursOld: number): Date {
+        const cutoffTime = new Date();
+        cutoffTime.setHours(cutoffTime.getHours() - hoursOld);
+        return cutoffTime;
+    }
+}

package/src/modules/payments/service.test.ts

@@ -0,0 +1,400 @@
+import { describe, it, beforeEach, mock } from 'node:test';
+import assert from 'node:assert';
+import { PaymentService } from './service';
+import type { PaymentEntity, IPaymentRepository } from './types';
+import type { IWayForPayService, WayForPayCallbackData } from './wayforpay.types';
+import type { Logger } from '../logger/types';
+
+// Mock logger
+const createMockLogger = (): Logger => ({
+    info: mock.fn(),
+    warning: mock.fn(),
+    error: mock.fn(),
+    debug: mock.fn(),
+});
+
+// Mock payment entity
+const createMockPayment = (overrides: Partial<PaymentEntity> = {}): PaymentEntity => ({
+    id: 'pay-123',
+    orderReference: 'order-123',
+    userId: 'user-123',
+    platform: 'telegram',
+    status: 'pending',
+    paymentLink: 'https://pay.example.com/link',
+    planId: 'plan-monthly',
+    paymentType: 'subscription',
+    amount: 100,
+    currency: 'UAH',
+    createdAt: new Date().toISOString(),
+    provider: 'wayforpay',
+    ...overrides,
+});
+
+// Mock callback data
+const createMockCallbackData = (overrides: Partial<WayForPayCallbackData> = {}): WayForPayCallbackData =>
+    ({
+        merchantAccount: 'test_merchant',
+        orderReference: 'order-123',
+        merchantSignature: 'valid-signature',
+        amount: 100,
+        currency: 'UAH',
+        authCode: 'auth-123',
+        email: 'test@example.com',
+        phone: '+380123456789',
+        createdDate: Date.now(),
+        processingDate: Date.now(),
+        cardPan: '4111****1111',
+        cardType: 'VISA',
+        issuerBankCountry: 'UA',
+        issuerBankName: 'Test Bank',
+        recToken: 'rec-token-123',
+        transactionStatus: 'Approved',
+        reason: 'Ok',
+        reasonCode: 1100,
+        fee: 2.5,
+        paymentSystem: 'VISA',
+        ...overrides,
+    }) as WayForPayCallbackData;
+
+// Mock repository
+const createMockRepository = (overrides: Partial<IPaymentRepository> = {}): IPaymentRepository => ({
+    getByOrderReference: mock.fn(async () => null),
+    getByUser: mock.fn(async () => []),
+    create: mock.fn(async (data) => ({ id: 'pay-new', ...data })),
+    updateFields: mock.fn(async () => {}),
+    getExpiredPendingPayments: mock.fn(async () => []),
+    ...overrides,
+});
+
+// Mock WayForPay service
+const createMockWayForPayService = (overrides: Partial<IWayForPayService> = {}): IWayForPayService => ({
+    generateSubscriptionPaymentUrl: mock.fn(async () => ({
+        url: 'https://pay.wayforpay.com/invoice',
+        orderReference: 'order-new',
+    })),
+    generateOneTimePaymentUrl: mock.fn(async () => ({
+        url: 'https://pay.wayforpay.com/invoice',
+        orderReference: 'order-new',
+    })),
+    verifyCallbackSignature: mock.fn(() => ({ isValid: true })),
+    buildWebhookResponse: mock.fn(() => ({
+        orderReference: 'order-123',
+        status: 'accept' as const,
+        time: Date.now(),
+        signature: 'response-signature',
+    })),
+    ...overrides,
+});
+
+describe('PaymentService', () => {
+    let logger: Logger;
+    let repository: IPaymentRepository;
+    let wayForPayService: IWayForPayService;
+    let service: PaymentService;
+
+    beforeEach(() => {
+        logger = createMockLogger();
+        repository = createMockRepository();
+        wayForPayService = createMockWayForPayService();
+        service = new PaymentService({ logger, repository, wayForPayService });
+    });
+
+    describe('getByOrderReference', () => {
+        it('should return payment when found', async () => {
+            const mockPayment = createMockPayment();
+            repository = createMockRepository({
+                getByOrderReference: mock.fn(async () => mockPayment),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            const result = await service.getByOrderReference('order-123');
+
+            assert.deepStrictEqual(result, mockPayment);
+        });
+
+        it('should return null when payment not found', async () => {
+            const result = await service.getByOrderReference('non-existent');
+
+            assert.strictEqual(result, null);
+        });
+
+        it('should return null and log error on repository error', async () => {
+            repository = createMockRepository({
+                getByOrderReference: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            const result = await service.getByOrderReference('order-123');
+
+            assert.strictEqual(result, null);
+            assert.strictEqual((logger.error as any).mock.calls.length, 1);
+        });
+    });
+
+    describe('getByUser', () => {
+        it('should return payments for user', async () => {
+            const payments = [createMockPayment(), createMockPayment({ id: 'pay-456' })];
+            repository = createMockRepository({
+                getByUser: mock.fn(async () => payments),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            const result = await service.getByUser({
+                userId: 'user-123',
+                platform: 'telegram',
+            });
+
+            assert.strictEqual(result.length, 2);
+        });
+
+        it('should filter by status when provided', async () => {
+            const getByUserMock = mock.fn(async () => [createMockPayment({ status: 'pending' })]);
+            repository = createMockRepository({ getByUser: getByUserMock });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            await service.getByUser({
+                userId: 'user-123',
+                platform: 'telegram',
+                status: 'pending',
+            });
+
+            const calls = (getByUserMock as any).mock.calls;
+            const callArgs = calls[0]?.arguments[0];
+            assert.strictEqual(callArgs?.userId, 'user-123');
+            assert.strictEqual(callArgs?.platform, 'telegram');
+            assert.strictEqual(callArgs?.status, 'pending');
+        });
+
+        it('should return empty array on error', async () => {
+            repository = createMockRepository({
+                getByUser: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            const result = await service.getByUser({
+                userId: 'user-123',
+                platform: 'telegram',
+            });
+
+            assert.deepStrictEqual(result, []);
+            assert.strictEqual((logger.error as any).mock.calls.length, 1);
+        });
+    });
+
+    describe('create', () => {
+        it('should create payment successfully', async () => {
+            const paymentData = {
+                orderReference: 'order-new',
+                userId: 'user-123',
+                status: 'pending' as const,
+                paymentLink: 'https://pay.example.com/new',
+                planId: 'plan-monthly',
+                paymentType: 'subscription' as const,
+                amount: 100,
+                currency: 'UAH' as const,
+                createdAt: new Date().toISOString(),
+                platform: 'telegram',
+                provider: 'wayforpay' as const,
+            };
+
+            const result = await service.create(paymentData);
+
+            assert.strictEqual(result.orderReference, paymentData.orderReference);
+            assert.strictEqual(result.userId, paymentData.userId);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                create: mock.fn(async () => {
+                    throw new Error('Create error');
+                }),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            await assert.rejects(
+                async () =>
+                    service.create({
+                        orderReference: 'order-new',
+                        userId: 'user-123',
+                        status: 'pending',
+                        paymentLink: 'https://pay.example.com/new',
+                        planId: 'plan-monthly',
+                        paymentType: 'subscription',
+                        amount: 100,
+                        currency: 'UAH',
+                        createdAt: new Date().toISOString(),
+                        platform: 'telegram',
+                        provider: 'wayforpay',
+                    }),
+                { message: 'Create error' },
+            );
+        });
+    });
+
+    describe('updateStatus', () => {
+        it('should update status successfully', async () => {
+            const updateFieldsMock = mock.fn(async () => {});
+            repository = createMockRepository({ updateFields: updateFieldsMock });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            await service.updateStatus({ id: 'pay-123', status: 'completed' });
+
+            const calls = (updateFieldsMock as any).mock.calls;
+            assert.strictEqual(calls.length, 1);
+            const callArgs = calls[0]?.arguments[0];
+            assert.strictEqual(callArgs?.id, 'pay-123');
+            assert.deepStrictEqual(callArgs?.fields, [['status', 'completed']]);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                updateFields: mock.fn(async () => {
+                    throw new Error('Update error');
+                }),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            await assert.rejects(async () => service.updateStatus({ id: 'pay-123', status: 'completed' }), {
+                message: 'Update error',
+            });
+        });
+    });
+
+    describe('changeStatus', () => {
+        it('should call updateStatus', async () => {
+            const updateFieldsMock = mock.fn(async () => {});
+            repository = createMockRepository({ updateFields: updateFieldsMock });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            await service.changeStatus({ id: 'pay-123', status: 'failed' });
+
+            assert.strictEqual(updateFieldsMock.mock.calls.length, 1);
+        });
+    });
+
+    describe('getExpiredPendingPayments', () => {
+        it('should return expired pending payments', async () => {
+            const expiredPayments = [
+                createMockPayment({ status: 'pending', createdAt: '2025-01-01T00:00:00.000Z' }),
+            ];
+            repository = createMockRepository({
+                getExpiredPendingPayments: mock.fn(async () => expiredPayments),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            const result = await service.getExpiredPendingPayments({ hoursOld: 24 });
+
+            assert.strictEqual(result.length, 1);
+        });
+
+        it('should return empty array on error', async () => {
+            repository = createMockRepository({
+                getExpiredPendingPayments: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            const result = await service.getExpiredPendingPayments();
+
+            assert.deepStrictEqual(result, []);
+            assert.strictEqual((logger.error as any).mock.calls.length, 1);
+        });
+    });
+
+    describe('createPaymentIntent', () => {
+        // Note: These tests require the external WayForPay API which uses createPaymentAPI
+        // directly. In a test environment without valid credentials, the API will fail.
+        // These tests verify the error handling behavior.
+
+        it('should throw and log error when API fails due to missing credentials', async () => {
+            // Without proper WayForPay credentials, the API will fail
+            await assert.rejects(
+                async () =>
+                    service.createPaymentIntent({
+                        userId: 'user-123',
+                        platform: 'telegram',
+                        planId: 'plan-monthly',
+                        productName: 'Monthly Subscription',
+                        productPrice: 100,
+                        currency: 'UAH',
+                        regularCount: 3,
+                        regularMode: 'monthly',
+                        language: 'UA',
+                    }),
+            );
+            // Error should be logged
+            assert.strictEqual((logger.error as any).mock.calls.length, 1);
+        });
+    });
+
+    describe('createTokenPackPaymentIntent', () => {
+        it('should throw and log error when API fails due to missing credentials', async () => {
+            // Without proper WayForPay credentials, the API will fail
+            await assert.rejects(
+                async () =>
+                    service.createTokenPackPaymentIntent({
+                        userId: 'user-123',
+                        platform: 'telegram',
+                        packId: 'token-pack-small',
+                        productName: 'Token Pack - 10000 tokens',
+                        productPrice: 49,
+                        currency: 'UAH',
+                        language: 'UA',
+                    }),
+            );
+            // Error should be logged
+            assert.strictEqual((logger.error as any).mock.calls.length, 1);
+        });
+    });
+
+    describe('validateSignature', () => {
+        it('should return valid result for valid signature', () => {
+            wayForPayService = createMockWayForPayService({
+                verifyCallbackSignature: mock.fn(() => ({ isValid: true })),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            const callbackData = createMockCallbackData();
+            const result = service.validateSignature(callbackData);
+
+            assert.strictEqual(result.isValid, true);
+            assert.strictEqual(result.error, undefined);
+        });
+
+        it('should return invalid result for invalid signature', () => {
+            wayForPayService = createMockWayForPayService({
+                verifyCallbackSignature: mock.fn(() => ({
+                    isValid: false,
+                    error: 'Signature mismatch',
+                })),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            const callbackData = createMockCallbackData({ merchantSignature: 'invalid' });
+            const result = service.validateSignature(callbackData);
+
+            assert.strictEqual(result.isValid, false);
+            assert.strictEqual(result.error, 'Signature mismatch');
+        });
+
+        it('should return error result on exception', () => {
+            wayForPayService = createMockWayForPayService({
+                verifyCallbackSignature: mock.fn(() => {
+                    throw new Error('Verification error');
+                }),
+            });
+            service = new PaymentService({ logger, repository, wayForPayService });
+
+            const callbackData = createMockCallbackData();
+            const result = service.validateSignature(callbackData);
+
+            assert.strictEqual(result.isValid, false);
+            assert.strictEqual(result.error, 'Error validating signature');
+        });
+    });
+});