@misterhomer1992/payment-manager 1.0.0

package/src/services/subscriptionService.ts

@@ -0,0 +1,183 @@
+import { getConfig } from '../config.js';
+import * as subscriptionsCollection from '../collections/subscriptions.js';
+import * as plansCollection from '../collections/plans.js';
+import * as paymentService from './paymentService.js';
+import { calculateUpgradeProration, cycleDays } from '../utils/proration.js';
+import { cancelRegularPurchase, editRegularPurchase } from '@misterhomer1992/wayforpay-api';
+import {
+	PlanNotFoundError,
+	PlanInactiveError,
+	SubscriptionNotFoundError,
+	PaymentProviderError,
+	PaymentManagerError,
+} from '../types/errors.js';
+import type { SubscriptionEntity } from '../types/index.js';
+
+export async function create(params: {
+	userId: string;
+	planId: string;
+	currency: string;
+	productName: string;
+}): Promise<{ paymentUrl: string }> {
+	const { logger } = getConfig();
+	const { userId, planId, currency, productName } = params;
+
+	const existing = await subscriptionsCollection.getActiveByUserId(userId);
+	if (existing) {
+		await subscriptionsCollection.update(existing.id, {
+			status: 'cancelled',
+		});
+	}
+
+	const plan = await plansCollection.getById(planId);
+	if (!plan) throw new PlanNotFoundError(planId);
+	if (!plan.isActive) throw new PlanInactiveError(planId);
+
+	const result = await paymentService.createSubscriptionPayment(userId, planId, currency, productName);
+
+	logger?.info('Subscription created', { userId, planId });
+	return result;
+}
+
+export async function expire(userId: string): Promise<void> {
+	const { logger } = getConfig();
+
+	const subscription = await subscriptionsCollection.getActiveByUserId(userId);
+	if (!subscription) throw new SubscriptionNotFoundError(userId);
+
+	await subscriptionsCollection.update(subscription.id, {
+		status: 'expired',
+	});
+
+	logger?.info('Subscription expired', {
+		userId,
+		subscriptionId: subscription.id,
+	});
+}
+
+export async function deactivate(userId: string): Promise<void> {
+	const { wayforpay, logger } = getConfig();
+
+	const subscription = await subscriptionsCollection.getActiveByUserId(userId);
+	if (!subscription) throw new SubscriptionNotFoundError(userId);
+
+	try {
+		await cancelRegularPurchase({
+			merchantAccount: wayforpay.merchantAccount,
+			orderReference: subscription.id,
+			merchantPassword: wayforpay.merchantSecretKey,
+		});
+	} catch (error) {
+		throw new PaymentProviderError(
+			`Failed to cancel regular purchase: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+
+	await subscriptionsCollection.update(subscription.id, {
+		status: 'cancelled',
+	});
+
+	logger?.info('Subscription cancelled', {
+		userId,
+		subscriptionId: subscription.id,
+	});
+}
+
+export async function changePlan(userId: string, newPlanId: string): Promise<void> {
+	const { wayforpay, logger } = getConfig();
+
+	const subscription = await subscriptionsCollection.getActiveByUserId(userId);
+	if (!subscription) throw new SubscriptionNotFoundError(userId);
+
+	const [currentPlan, newPlan] = await Promise.all([
+		plansCollection.getById(subscription.planId),
+		plansCollection.getById(newPlanId),
+	]);
+
+	if (!currentPlan) throw new PlanNotFoundError(subscription.planId);
+	if (!newPlan) throw new PlanNotFoundError(newPlanId);
+	if (!newPlan.isActive) throw new PlanInactiveError(newPlanId);
+
+	if (newPlan.amount === currentPlan.amount) {
+		throw new PaymentManagerError('Cannot change to a plan with the same price', 'SAME_PRICE_PLAN_CHANGE');
+	}
+
+	const now = new Date();
+	const isUpgrade = newPlan.amount > currentPlan.amount;
+
+	if (isUpgrade) {
+		const proration = calculateUpgradeProration(
+			currentPlan,
+			newPlan,
+			subscription.startedAt,
+			subscription.expiresAt,
+			now,
+		);
+
+		await subscriptionsCollection.update(subscription.id, {
+			planId: newPlanId,
+			expiresAt: proration.newExpiresAt,
+		});
+
+		try {
+			await editRegularPurchase({
+				merchantAccount: wayforpay.merchantAccount,
+				merchantPassword: wayforpay.merchantSecretKey,
+				orderReference: subscription.id,
+				amount: newPlan.amount,
+				currency: 'UAH',
+				regularMode: newPlan.regularMode,
+				dateBegin: now.toISOString().split('T')[0],
+				dateEnd: '',
+			});
+		} catch (error) {
+			throw new PaymentProviderError(
+				`Failed to edit regular purchase: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+
+		logger?.info('Subscription upgraded', {
+			userId,
+			subscriptionId: subscription.id,
+			oldPlanId: subscription.planId,
+			newPlanId,
+			newExpiresAt: proration.newExpiresAt.toISOString(),
+		});
+	} else {
+		const pendingPlanChangeDate = subscription.expiresAt;
+
+		await subscriptionsCollection.update(subscription.id, {
+			pendingPlanId: newPlanId,
+			pendingPlanChangeDate,
+		});
+
+		try {
+			await editRegularPurchase({
+				merchantAccount: wayforpay.merchantAccount,
+				merchantPassword: wayforpay.merchantSecretKey,
+				orderReference: subscription.id,
+				amount: newPlan.amount,
+				currency: 'UAH',
+				regularMode: newPlan.regularMode,
+				dateBegin: pendingPlanChangeDate.toISOString().split('T')[0],
+				dateEnd: '',
+			});
+		} catch (error) {
+			throw new PaymentProviderError(
+				`Failed to edit regular purchase: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+
+		logger?.info('Subscription downgraded', {
+			userId,
+			subscriptionId: subscription.id,
+			oldPlanId: subscription.planId,
+			newPlanId,
+			pendingPlanChangeDate: pendingPlanChangeDate.toISOString(),
+		});
+	}
+}
+
+export async function getActiveByUserId(userId: string): Promise<SubscriptionEntity | null> {
+	return subscriptionsCollection.getActiveByUserId(userId);
+}

package/src/services/tokenPackService.ts

@@ -0,0 +1,54 @@
+import { getConfig } from '../config.js';
+import * as tokenPacksCollection from '../collections/tokenPacks.js';
+import * as userTokenBalancesCollection from '../collections/userTokenBalances.js';
+import * as paymentService from './paymentService.js';
+import { TokenPackNotFoundError, TokenPackInactiveError } from '../types/errors.js';
+import type { TokenPackEntity, UserTokenBalance } from '../types/index.js';
+
+export async function create(pack: Omit<TokenPackEntity, 'id' | 'createdAt' | 'updatedAt'>): Promise<string> {
+	const { logger } = getConfig();
+
+	const packId = await tokenPacksCollection.create(pack);
+
+	logger?.info('Token pack created', { packId, name: pack.name, tokenAmount: pack.tokenAmount, price: pack.price });
+	return packId;
+}
+
+export async function remove(packId: string): Promise<void> {
+	await tokenPacksCollection.remove(packId);
+}
+
+export async function activate(packId: string): Promise<void> {
+	await tokenPacksCollection.update(packId, { isActive: true });
+}
+
+export async function deactivate(packId: string): Promise<void> {
+	await tokenPacksCollection.update(packId, { isActive: false });
+}
+
+export async function getAll(): Promise<TokenPackEntity[]> {
+	return tokenPacksCollection.getAll();
+}
+
+export async function buyExtraTokens(params: {
+	userId: string;
+	packId: string;
+	currency: string;
+	productName: string;
+}): Promise<{ paymentUrl: string }> {
+	const { userId, packId, currency, productName } = params;
+	const { logger } = getConfig();
+
+	const pack = await tokenPacksCollection.getById(packId);
+	if (!pack) throw new TokenPackNotFoundError(packId);
+	if (!pack.isActive) throw new TokenPackInactiveError(packId);
+
+	const result = await paymentService.createTokenPackPayment(userId, packId, currency, productName, pack.price);
+
+	logger?.info('Token pack purchase initiated', { userId, packId, price: pack.price });
+	return result;
+}
+
+export async function getBalance(userId: string): Promise<UserTokenBalance> {
+	return userTokenBalancesCollection.getByUserId(userId);
+}

package/src/services/webhookService.ts

@@ -0,0 +1,217 @@
+import { getConfig } from '../config.js';
+import { parseOrderReference } from '../utils/orderReference.js';
+import { buildWebhookResponse } from '../utils/webhookResponse.js';
+import { cycleDays } from '../utils/proration.js';
+import { getExpirationWithGrace } from '../utils/gracePeriod.js';
+import * as paymentsCollection from '../collections/payments.js';
+import * as subscriptionsCollection from '../collections/subscriptions.js';
+import * as plansCollection from '../collections/plans.js';
+import * as tokenPacksCollection from '../collections/tokenPacks.js';
+import * as userTokenBalancesCollection from '../collections/userTokenBalances.js';
+import { InvalidWebhookSecretError } from '../types/errors.js';
+import type { WebhookResponse, DeactivationResult, ServiceUrlRequestParams } from '../types/webhook.js';
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+const SUCCESS_REASON_CODES = [1100, 4100];
+
+export async function handlePaymentCheck(
+	reqBody: Record<string, unknown>,
+	headers: Record<string, string | undefined>,
+): Promise<WebhookResponse> {
+	const { wayforpay, webhookSecret, logger } = getConfig();
+
+	// Validate webhook secret
+	const secret = webhookSecret ?? process.env.NOTIFY_TELEGRAM_USER_SECRET;
+	const headerSecret = headers['x-secret-key'];
+
+	if (secret && headerSecret !== secret) {
+		throw new InvalidWebhookSecretError();
+	}
+
+	// Parse request body (WayForPay sends body as JSON key)
+	const parsed: ServiceUrlRequestParams = JSON.parse(Object.keys(reqBody)[0]);
+
+	const { orderReference, reasonCode } = parsed;
+
+	logger?.info('Webhook received', { orderReference, reasonCode });
+
+	// Check if payment is successful
+	if (!SUCCESS_REASON_CODES.includes(reasonCode)) {
+		return buildWebhookResponse(orderReference, 'reject', wayforpay.merchantSecretKey);
+	}
+
+	const ref = parseOrderReference(orderReference);
+
+	if (ref.type === 'sub') {
+		await handleSubscriptionPayment(ref.userId, ref.planId!, orderReference);
+	} else {
+		await handleTokenPackPayment(ref.userId, ref.tokenPackId!, orderReference);
+	}
+
+	// Update payment status to approved
+	const payment = await paymentsCollection.findByOrderReference(orderReference);
+	if (payment) {
+		await paymentsCollection.update(payment.id, { status: 'approved' });
+	}
+
+	return buildWebhookResponse(orderReference, 'accept', wayforpay.merchantSecretKey);
+}
+
+async function handleSubscriptionPayment(userId: string, planId: string, orderReference: string): Promise<void> {
+	const { logger } = getConfig();
+
+	const existing = await subscriptionsCollection.getActiveByUserId(userId);
+
+	if (existing) {
+		// Recurrent payment — check for pending downgrade first
+		const now = new Date();
+		if (existing.pendingPlanId && existing.pendingPlanChangeDate && existing.pendingPlanChangeDate <= now) {
+			// Apply pending downgrade
+			const newPlanId = existing.pendingPlanId;
+			const plan = await plansCollection.getById(newPlanId);
+			const days = plan ? cycleDays(plan.regularMode) : cycleDays('monthly');
+			const newExpiresAt = new Date(now.getTime() + days * MS_PER_DAY);
+
+			await subscriptionsCollection.update(existing.id, {
+				planId: newPlanId,
+				expiresAt: newExpiresAt,
+				startedAt: now,
+				pendingPlanId: undefined,
+				pendingPlanChangeDate: undefined,
+			});
+
+			logger?.info('Subscription downgrade applied', {
+				userId,
+				subscriptionId: existing.id,
+				oldPlanId: existing.planId,
+				newPlanId,
+			});
+		} else {
+			// Extend subscription
+			const plan = await plansCollection.getById(existing.planId);
+			const days = plan ? cycleDays(plan.regularMode) : cycleDays('monthly');
+			const newExpiresAt = new Date(existing.expiresAt.getTime() + days * MS_PER_DAY);
+
+			await subscriptionsCollection.update(existing.id, {
+				expiresAt: newExpiresAt,
+			});
+
+			logger?.info('Subscription renewed', {
+				userId,
+				subscriptionId: existing.id,
+				newExpiresAt: newExpiresAt.toISOString(),
+			});
+		}
+	} else {
+		// First payment — create new subscription
+		const plan = await plansCollection.getById(planId);
+		const days = plan ? cycleDays(plan.regularMode) : cycleDays('monthly');
+		const now = new Date();
+		const expiresAt = new Date(now.getTime() + days * MS_PER_DAY);
+
+		const subscriptionId = await subscriptionsCollection.create({
+			userId,
+			planId,
+			status: 'active',
+			startedAt: now,
+			expiresAt,
+		});
+
+		logger?.info('Subscription created', {
+			userId,
+			subscriptionId,
+			planId,
+			expiresAt: expiresAt.toISOString(),
+		});
+	}
+}
+
+async function handleTokenPackPayment(userId: string, tokenPackId: string, orderReference: string): Promise<void> {
+	const { logger } = getConfig();
+
+	const pack = await tokenPacksCollection.getById(tokenPackId);
+	if (!pack) {
+		logger?.warn('Token pack not found for webhook', { tokenPackId, orderReference });
+		return;
+	}
+
+	await userTokenBalancesCollection.addTokens(userId, pack.tokenAmount);
+
+	logger?.info('Tokens added', {
+		userId,
+		tokenPackId,
+		tokenAmount: pack.tokenAmount,
+	});
+}
+
+export async function handleSubscriptionDeactivationCheck(
+	headers: Record<string, string | undefined>,
+): Promise<DeactivationResult> {
+	const { webhookSecret, logger } = getConfig();
+
+	const secret = webhookSecret ?? process.env.NOTIFY_TELEGRAM_USER_SECRET;
+	const headerSecret = headers['x-secret-key'];
+
+	if (secret && headerSecret !== secret) {
+		throw new InvalidWebhookSecretError();
+	}
+
+	const subscriptions = await subscriptionsCollection.getAllActiveAndCancelled();
+	const now = new Date();
+
+	const expired: string[] = [];
+	const downgraded: string[] = [];
+
+	for (const subscription of subscriptions) {
+		const plan = await plansCollection.getById(subscription.planId);
+		if (!plan) continue;
+
+		const expirationWithGrace = getExpirationWithGrace(subscription.expiresAt, plan.regularMode);
+
+		if (now > expirationWithGrace) {
+			await subscriptionsCollection.update(subscription.id, { status: 'expired' });
+			expired.push(subscription.userId);
+
+			logger?.info('Subscription expired by deactivation check', {
+				userId: subscription.userId,
+				subscriptionId: subscription.id,
+			});
+			continue;
+		}
+
+		if (
+			subscription.pendingPlanId &&
+			subscription.pendingPlanChangeDate &&
+			subscription.pendingPlanChangeDate <= now
+		) {
+			const newPlanId = subscription.pendingPlanId;
+			const newPlan = await plansCollection.getById(newPlanId);
+			const days = newPlan ? cycleDays(newPlan.regularMode) : cycleDays('monthly');
+			const newExpiresAt = new Date(now.getTime() + days * MS_PER_DAY);
+
+			await subscriptionsCollection.update(subscription.id, {
+				planId: newPlanId,
+				expiresAt: newExpiresAt,
+				startedAt: now,
+				pendingPlanId: undefined,
+				pendingPlanChangeDate: undefined,
+			});
+
+			downgraded.push(subscription.userId);
+
+			logger?.info('Subscription downgrade applied by deactivation check', {
+				userId: subscription.userId,
+				subscriptionId: subscription.id,
+				oldPlanId: subscription.planId,
+				newPlanId,
+			});
+		}
+	}
+
+	logger?.info('Deactivation check completed', {
+		expiredCount: expired.length,
+		downgradedCount: downgraded.length,
+	});
+
+	return { expired, downgraded };
+}

package/src/types/errors.ts

@@ -0,0 +1,72 @@
+export class PaymentManagerError extends Error {
+	public readonly code: string;
+
+	constructor(message: string, code: string) {
+		super(message);
+		this.name = 'PaymentManagerError';
+		this.code = code;
+	}
+}
+
+export class PlanNotFoundError extends PaymentManagerError {
+	constructor(planId: string) {
+		super(`Plan not found: ${planId}`, 'PLAN_NOT_FOUND');
+		this.name = 'PlanNotFoundError';
+	}
+}
+
+export class PlanInactiveError extends PaymentManagerError {
+	constructor(planId: string) {
+		super(`Plan is inactive: ${planId}`, 'PLAN_INACTIVE');
+		this.name = 'PlanInactiveError';
+	}
+}
+
+export class SubscriptionAlreadyActiveError extends PaymentManagerError {
+	constructor(userId: string) {
+		super(`User already has an active subscription: ${userId}`, 'SUBSCRIPTION_ALREADY_ACTIVE');
+		this.name = 'SubscriptionAlreadyActiveError';
+	}
+}
+
+export class SubscriptionNotFoundError extends PaymentManagerError {
+	constructor(userId: string) {
+		super(`No active subscription found for user: ${userId}`, 'SUBSCRIPTION_NOT_FOUND');
+		this.name = 'SubscriptionNotFoundError';
+	}
+}
+
+export class TokenPackNotFoundError extends PaymentManagerError {
+	constructor(packId: string) {
+		super(`Token pack not found: ${packId}`, 'TOKEN_PACK_NOT_FOUND');
+		this.name = 'TokenPackNotFoundError';
+	}
+}
+
+export class TokenPackInactiveError extends PaymentManagerError {
+	constructor(packId: string) {
+		super(`Token pack is inactive: ${packId}`, 'TOKEN_PACK_INACTIVE');
+		this.name = 'TokenPackInactiveError';
+	}
+}
+
+export class InvalidWebhookSecretError extends PaymentManagerError {
+	constructor() {
+		super('Invalid webhook secret', 'INVALID_WEBHOOK_SECRET');
+		this.name = 'InvalidWebhookSecretError';
+	}
+}
+
+export class PaymentProviderError extends PaymentManagerError {
+	constructor(message: string) {
+		super(message, 'PAYMENT_PROVIDER_ERROR');
+		this.name = 'PaymentProviderError';
+	}
+}
+
+export class InvalidOrderReferenceError extends PaymentManagerError {
+	constructor(orderReference: string) {
+		super(`Invalid order reference: ${orderReference}`, 'INVALID_ORDER_REFERENCE');
+		this.name = 'InvalidOrderReferenceError';
+	}
+}

package/src/types/index.ts

@@ -0,0 +1,18 @@
+export { SubscriptionPlanEntity } from './plan.js';
+export { SubscriptionEntity } from './subscription.js';
+export { PaymentEntity } from './payment.js';
+export { TokenPackEntity, UserTokenBalance } from './tokenPack.js';
+export { WebhookResponse, DeactivationResult, ServiceUrlRequestParams } from './webhook.js';
+export { OrderReferenceParams, ParsedOrderReference } from './orderReference.js';
+export {
+	PaymentManagerError,
+	PlanNotFoundError,
+	PlanInactiveError,
+	SubscriptionAlreadyActiveError,
+	SubscriptionNotFoundError,
+	TokenPackNotFoundError,
+	TokenPackInactiveError,
+	InvalidWebhookSecretError,
+	PaymentProviderError,
+	InvalidOrderReferenceError,
+} from './errors.js';

package/src/types/orderReference.ts

@@ -0,0 +1,19 @@
+export interface OrderReferenceParams {
+	version: string;
+	platform: string;
+	userId: string;
+	type: 'sub' | 'tkn';
+	planId?: string;
+	tokenPackId?: string;
+	date: Date;
+}
+
+export interface ParsedOrderReference {
+	version: string;
+	platform: string;
+	userId: string;
+	type: 'sub' | 'tkn';
+	planId?: string;
+	tokenPackId?: string;
+	date: Date;
+}

package/src/types/payment.ts

@@ -0,0 +1,14 @@
+export interface PaymentEntity {
+	id: string;
+	userId: string;
+	planId?: string;
+	tokenPackId?: string;
+	amount: number;
+	currency: string;
+	status: 'pending' | 'approved' | 'rejected';
+	orderReference: string;
+	paymentLink?: string;
+	paymentLinkCreatedAt?: Date;
+	createdAt: Date;
+	updatedAt: Date;
+}

package/src/types/plan.ts

@@ -0,0 +1,10 @@
+export interface SubscriptionPlanEntity {
+	id: string;
+	name: string;
+	amount: number;
+	regularMode: 'daily' | 'monthly' | 'yearly';
+	description?: string;
+	isActive: boolean;
+	createdAt: Date;
+	updatedAt: Date;
+}

package/src/types/subscription.ts

@@ -0,0 +1,12 @@
+export interface SubscriptionEntity {
+	id: string;
+	userId: string;
+	planId: string;
+	status: 'active' | 'cancelled' | 'expired';
+	startedAt: Date;
+	expiresAt: Date;
+	pendingPlanId?: string;
+	pendingPlanChangeDate?: Date;
+	createdAt: Date;
+	updatedAt: Date;
+}

package/src/types/tokenPack.ts

@@ -0,0 +1,16 @@
+export interface TokenPackEntity {
+	id: string;
+	name: string;
+	tokenAmount: number;
+	price: number;
+	isActive: boolean;
+	createdAt: Date;
+	updatedAt: Date;
+}
+
+export interface UserTokenBalance {
+	userId: string;
+	balance: number;
+	totalPurchased: number;
+	updatedAt: Date;
+}

package/src/types/webhook.ts

@@ -0,0 +1,34 @@
+export interface WebhookResponse {
+	orderReference: string;
+	status: 'accept' | 'reject';
+	time: string;
+	signature: string;
+}
+
+export interface DeactivationResult {
+	expired: string[];
+	downgraded: string[];
+}
+
+export interface ServiceUrlRequestParams {
+	merchantAccount: string;
+	orderReference: string;
+	merchantSignature: string;
+	amount: number;
+	currency: string;
+	authCode: string;
+	email: string;
+	phone: string;
+	createdDate: number;
+	processingDate: number;
+	cardPan: string;
+	cardType: string;
+	issuerBankCountry: string;
+	issuerBankName: string;
+	recToken: string;
+	transactionStatus: string;
+	reason: string;
+	reasonCode: number;
+	fee: number;
+	paymentSystem: string;
+}