@misterhomer1992/miit-bot-payment 1.1.7 → 2.0.4

package/src/modules/subscription/service.ts

@@ -0,0 +1,328 @@
+import moment from 'moment';
+import { Logger } from '../logger/types';
+import { SubscriptionRepository, UpdateDBSubscriptionFields } from './repository';
+import { SubscriptionEntity, ISubscriptionRepository, ISubscriptionService, SubscriptionPlan } from './types';
+import { getSubscriptionTitle } from './utils';
+import { PaymentService } from '../payments/service';
+import { IPaymentService } from '../payments/types';
+import { ConfigurationManager, GracePeriodConfig, DEFAULT_GRACE_PERIOD_CONFIG } from '../../config';
+
+export class SubscriptionService implements ISubscriptionService {
+    private readonly logger: Logger;
+    private readonly repository: ISubscriptionRepository;
+    private readonly paymentService: IPaymentService;
+    private readonly gracePeriodConfig: GracePeriodConfig;
+
+    constructor({
+        logger,
+        repository,
+        paymentService,
+        gracePeriodConfig,
+    }: {
+        logger: Logger;
+        repository?: ISubscriptionRepository;
+        paymentService?: IPaymentService;
+        gracePeriodConfig?: GracePeriodConfig;
+    }) {
+        this.logger = logger;
+        this.repository = repository || new SubscriptionRepository();
+        this.paymentService = paymentService || new PaymentService({ logger });
+        this.gracePeriodConfig = gracePeriodConfig || this.loadGracePeriodConfig();
+    }
+
+    private loadGracePeriodConfig(): GracePeriodConfig {
+        try {
+            const configManager = ConfigurationManager.getInstance();
+            return configManager.getGracePeriodConfig();
+        } catch {
+            return DEFAULT_GRACE_PERIOD_CONFIG;
+        }
+    }
+
+    public async getByUser(params: {
+        userId: string;
+        platform: string;
+        status?: SubscriptionEntity['status'] | SubscriptionEntity['status'][];
+    }): Promise<SubscriptionEntity | null> {
+        try {
+            return await this.repository.getByUser(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service getByUser',
+                payload: {
+                    userId: params.userId,
+                    platform: params.platform,
+                    error: JSON.stringify(error),
+                },
+            });
+            return null;
+        }
+    }
+
+    public async create(params: {
+        userId: string;
+        platform: string;
+        planId: string;
+        expiresAt: string;
+        startedAt: string;
+    }): Promise<SubscriptionEntity> {
+        try {
+            return await this.repository.create(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service create',
+                payload: {
+                    userId: params.userId,
+                    platform: params.platform,
+                    planId: params.planId,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+    public async updateFieldsByUserId(params: {
+        userId: string;
+        platform: string;
+        fields: UpdateDBSubscriptionFields;
+    }): Promise<void> {
+        try {
+            await this.repository.updateFieldsByUserId(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service updateFieldsByUserId',
+                payload: {
+                    userId: params.userId,
+                    platform: params.platform,
+                    fields: JSON.stringify(params.fields),
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+
+    public async getExpiredActiveSubscriptions(): Promise<SubscriptionEntity[]> {
+        try {
+            return await this.repository.getExpiredActiveSubscriptions();
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service getExpiredActiveSubscriptions',
+                payload: {
+                    error: JSON.stringify(error),
+                },
+            });
+            return [];
+        }
+    }
+
+    public async updateFieldsById(params: {
+        subscriptionId: string;
+        fields: UpdateDBSubscriptionFields;
+    }): Promise<void> {
+        try {
+            await this.repository.updateFieldsById(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service updateFieldsById',
+                payload: {
+                    subscriptionId: params.subscriptionId,
+                    fields: JSON.stringify(params.fields),
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+
+    public async getOrCreateSubscriptionPaymentUrl(params: {
+        userId: string;
+        platform: string;
+        languageCode: string;
+        translate: (params: { code: string; path: string }) => string;
+        subscriptionPlan: SubscriptionPlan;
+    }): Promise<string> {
+        try {
+            // Check for existing pending payments for this plan
+            const existingPayments = await this.paymentService.getByUser({
+                userId: params.userId,
+                platform: params.platform,
+                status: 'pending',
+            });
+
+            const recentPayment = existingPayments
+                .filter((payment) => payment.planId === params.subscriptionPlan.id)
+                .find((payment) => moment.utc().diff(moment.utc(payment.createdAt), 'minutes') < 10);
+
+            if (recentPayment && recentPayment.paymentLink) {
+                return recentPayment.paymentLink;
+            }
+
+            const productName = getSubscriptionTitle(
+                params.translate({
+                    code: params.languageCode,
+                    path: params.subscriptionPlan.titleCode,
+                }),
+            );
+
+            const paymentEntity = await this.paymentService.createPaymentIntent({
+                userId: params.userId,
+                platform: params.platform,
+                planId: params.subscriptionPlan.id,
+                productName,
+                productPrice: params.subscriptionPlan.amount,
+                currency: params.subscriptionPlan.currency,
+                language: params.languageCode,
+                regularMode: params.subscriptionPlan.regularMode,
+                regularCount: params.subscriptionPlan.count,
+            });
+
+            return paymentEntity.paymentLink;
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service getOrCreateSubscriptionPaymentUrl',
+                payload: {
+                    userId: params.userId,
+                    platform: params.platform,
+                    planId: params.subscriptionPlan.id,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+
+    public async activateSubscription(params: Omit<SubscriptionEntity, 'id' | 'status'>): Promise<void> {
+        try {
+            await this.repository.activateSubscription(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service activateSubscription',
+                payload: {
+                    userId: params.userId,
+                    platform: params.platform,
+                    planId: params.planId,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+
+    public async renewSubscription(
+        params: Pick<SubscriptionEntity, 'userId' | 'platform' | 'expiresAt'>,
+    ): Promise<void> {
+        try {
+            await this.repository.renewSubscription(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service renewSubscription',
+                payload: {
+                    userId: params.userId,
+                    platform: params.platform,
+                    expiresAt: params.expiresAt,
+                    error: JSON.stringify(error),
+                },
+            });
+            throw error;
+        }
+    }
+
+    public async getSubscriptionsForDeactivationCheck(): Promise<SubscriptionEntity[]> {
+        try {
+            return (await this.repository.getByStatus({ status: ['active', 'cancelled'] })).filter(
+                (subscription) => subscription.id !== 'unlimited',
+            );
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service getSubscriptionsForDeactivationCheck',
+                payload: { error: JSON.stringify(error) },
+            });
+
+            throw error;
+        }
+    }
+
+    public async deactivateSubscription({ id }: Pick<SubscriptionEntity, 'id'>): Promise<void> {
+        try {
+            await this.repository.deactivateSubscription({ id });
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service deactivateSubscription',
+                payload: {
+                    id,
+                    error: JSON.stringify(error),
+                },
+            });
+            throw error;
+        }
+    }
+
+    public async cancelSubscription({ id }: Pick<SubscriptionEntity, 'id'>): Promise<void> {
+        try {
+            await this.repository.cancelSubscription({ id });
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service cancelSubscription',
+                payload: { id, error: JSON.stringify(error) },
+            });
+        }
+    }
+
+    public async getExpiredSubscriptions(): Promise<SubscriptionEntity[]> {
+        try {
+            const expiredSubscriptions = await this.repository.getExpiredActiveSubscriptions();
+
+            if (!this.gracePeriodConfig.enabled || this.gracePeriodConfig.durationMs === 0) {
+                return expiredSubscriptions;
+            }
+
+            const now = moment.utc();
+            return expiredSubscriptions.filter((subscription) => {
+                const expiresAt = moment.utc(subscription.expiresAt);
+                const gracePeriodEnd = expiresAt.add(this.gracePeriodConfig.durationMs, 'milliseconds');
+                return now.isAfter(gracePeriodEnd);
+            });
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service getExpiredSubscriptions',
+                payload: { error: JSON.stringify(error) },
+            });
+            return [];
+        }
+    }
+
+    public async getFailedRenewals(): Promise<SubscriptionEntity[]> {
+        try {
+            const cancelledSubscriptions = await this.repository.getByStatus({ status: 'cancelled' });
+
+            const now = moment.utc();
+            const gracePeriodMs = this.gracePeriodConfig.enabled ? this.gracePeriodConfig.durationMs : 0;
+
+            return cancelledSubscriptions.filter((subscription) => {
+                if (subscription.id === 'unlimited') {
+                    return false;
+                }
+
+                const expiresAt = moment.utc(subscription.expiresAt);
+                const gracePeriodEnd = expiresAt.add(gracePeriodMs, 'milliseconds');
+                return now.isAfter(gracePeriodEnd);
+            });
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription service getFailedRenewals',
+                payload: { error: JSON.stringify(error) },
+            });
+            return [];
+        }
+    }
+
+    public async deactivate({ id }: Pick<SubscriptionEntity, 'id'>): Promise<void> {
+        return this.deactivateSubscription({ id });
+    }
+}

package/src/modules/subscription/status-check.handler.ts

@@ -0,0 +1,254 @@
+import { Logger } from '../logger/types';
+import { SubscriptionService } from './service';
+import { TokenService } from '../token/service';
+import { ISubscriptionService, SubscriptionEntity } from './types';
+import { ITokenService, TokenBalance } from '../token/types';
+
+/**
+ * Request object interface for status check handling.
+ * Compatible with Express.js and similar frameworks.
+ */
+interface StatusCheckRequest {
+    body: unknown;
+}
+
+/**
+ * Response object interface for status check handling.
+ * Compatible with Express.js and similar frameworks.
+ */
+interface StatusCheckResponse {
+    status(code: number): StatusCheckResponse;
+    json(data: unknown): void;
+}
+
+/**
+ * Configuration options for the status check handler.
+ */
+interface StatusCheckHandlerConfig {
+    logger: Logger;
+    subscriptionService?: ISubscriptionService;
+    tokenService?: ITokenService;
+}
+
+/**
+ * Request body for subscription status check.
+ */
+interface StatusCheckRequestBody {
+    userId: string;
+    platform: string;
+}
+
+/**
+ * Response payload for subscription status check.
+ */
+interface SubscriptionStatusResponse {
+    /** Whether the user has an active subscription */
+    hasActiveSubscription: boolean;
+    /** Current subscription details, null if no subscription exists */
+    subscription: SubscriptionEntity | null;
+    /** User's token balance */
+    tokenBalance: TokenBalance;
+}
+
+/**
+ * Result of parsing the status check request body.
+ */
+interface ParseResult {
+    success: boolean;
+    data?: StatusCheckRequestBody;
+    error?: string;
+}
+
+/**
+ * SubscriptionStatusCheckHandler provides HTTP request handling for checking
+ * a user's subscription status. It returns subscription details, token balance,
+ * and active status.
+ *
+ * Usage with Express:
+ * ```typescript
+ * const handler = new SubscriptionStatusCheckHandler({ logger });
+ * app.post('/api/subscription/status', (req, res) => handler.handleRequest(req, res));
+ * ```
+ *
+ * Usage with Cloud Functions:
+ * ```typescript
+ * const handler = new SubscriptionStatusCheckHandler({ logger });
+ * export const statusCheck = (req, res) => handler.handleRequest(req, res);
+ * ```
+ */
+export class SubscriptionStatusCheckHandler {
+    private readonly logger: Logger;
+    private readonly subscriptionService: ISubscriptionService;
+    private readonly tokenService: ITokenService;
+
+    constructor(config: StatusCheckHandlerConfig) {
+        this.logger = config.logger;
+        this.subscriptionService = config.subscriptionService || new SubscriptionService({ logger: config.logger });
+        this.tokenService = config.tokenService || new TokenService({ logger: config.logger });
+    }
+
+    /**
+     * Handles an incoming HTTP request to check subscription status.
+     * Validates the request body, retrieves subscription and token data,
+     * and returns the appropriate response.
+     *
+     * @param req - The HTTP request object
+     * @param res - The HTTP response object
+     */
+    public async handleRequest(req: StatusCheckRequest, res: StatusCheckResponse): Promise<void> {
+        this.logger.info({
+            message: 'Received subscription status check request',
+            payload: {},
+        });
+
+        // Parse and validate the request body
+        const parseResult = this.parseRequestBody(req.body);
+
+        if (!parseResult.success || !parseResult.data) {
+            this.logger.warning({
+                message: 'Invalid status check request body',
+                payload: { error: parseResult.error },
+            });
+
+            res.status(400).json({
+                error: parseResult.error || 'Invalid request body',
+            });
+            return;
+        }
+
+        const { userId, platform } = parseResult.data;
+
+        try {
+            // Get subscription status
+            const statusResult = await this.checkStatus({ userId, platform });
+
+            this.logger.info({
+                message: 'Subscription status check completed',
+                payload: {
+                    userId,
+                    platform,
+                    hasActiveSubscription: statusResult.hasActiveSubscription,
+                    subscriptionStatus: statusResult.subscription?.status || null,
+                    tokenBalance: statusResult.tokenBalance.available,
+                },
+            });
+
+            res.status(200).json(statusResult);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error checking subscription status',
+                payload: {
+                    userId,
+                    platform,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            res.status(500).json({
+                error: 'Internal server error while checking subscription status',
+            });
+        }
+    }
+
+    /**
+     * Checks subscription status directly without HTTP request parsing.
+     * Useful for internal calls or testing.
+     *
+     * @param params - User identification parameters
+     * @returns Subscription status response
+     */
+    public async checkStatus(params: { userId: string; platform: string }): Promise<SubscriptionStatusResponse> {
+        const { userId, platform } = params;
+
+        // Fetch subscription and token balance in parallel
+        const [subscription, tokenBalance] = await Promise.all([
+            this.subscriptionService.getByUser({ userId, platform }),
+            this.tokenService.getBalance({ userId, platform }),
+        ]);
+
+        // Determine if subscription is active
+        const hasActiveSubscription = subscription?.status === 'active';
+
+        return {
+            hasActiveSubscription,
+            subscription,
+            tokenBalance,
+        };
+    }
+
+    /**
+     * Parses and validates the status check request body.
+     */
+    private parseRequestBody(body: unknown): ParseResult {
+        if (!body || typeof body !== 'object') {
+            return {
+                success: false,
+                error: 'Request body must be a JSON object',
+            };
+        }
+
+        const data = body as Record<string, unknown>;
+
+        // Validate required fields
+        if (!data.userId || typeof data.userId !== 'string') {
+            return {
+                success: false,
+                error: 'Missing or invalid required field: userId',
+            };
+        }
+
+        if (!data.platform || typeof data.platform !== 'string') {
+            return {
+                success: false,
+                error: 'Missing or invalid required field: platform',
+            };
+        }
+
+        return {
+            success: true,
+            data: {
+                userId: data.userId,
+                platform: data.platform,
+            },
+        };
+    }
+}
+
+/**
+ * Creates a subscription status check handler function for use with serverless platforms.
+ * Returns a function that can be directly used as a Cloud Function or Lambda handler.
+ *
+ * @param config - Configuration options for the status check handler
+ * @returns An async function that handles status check requests
+ *
+ * @example
+ * ```typescript
+ * // Firebase Cloud Functions
+ * import * as functions from 'firebase-functions';
+ * import { createSubscriptionStatusCheckHandler } from 'miit-bot-payment';
+ *
+ * const logger = { info: console.log, warning: console.warn, error: console.error };
+ * export const subscriptionStatus = functions.https.onRequest(
+ *   createSubscriptionStatusCheckHandler({ logger })
+ * );
+ * ```
+ */
+export function createSubscriptionStatusCheckHandler(
+    config: StatusCheckHandlerConfig,
+): (req: StatusCheckRequest, res: StatusCheckResponse) => Promise<void> {
+    const handler = new SubscriptionStatusCheckHandler(config);
+    return (req: StatusCheckRequest, res: StatusCheckResponse) => handler.handleRequest(req, res);
+}
+
+/**
+ * Type export for the status check handler function signature.
+ */
+export type StatusCheckHandlerFunction = (req: StatusCheckRequest, res: StatusCheckResponse) => Promise<void>;
+
+export type {
+    StatusCheckRequest,
+    StatusCheckResponse,
+    StatusCheckHandlerConfig,
+    StatusCheckRequestBody,
+    SubscriptionStatusResponse,
+};