@windrun-huaiin/backend-core 10.0.1

package/dist/services/database/subscription.service.d.ts

@@ -0,0 +1,48 @@
+import type { Prisma, Subscription } from './prisma-model-type';
+export declare class SubscriptionService {
+    /**
+     * Initialize a placeholder subscription record for new users
+     * This allows Stripe webhook handlers to UPDATE instead of CREATE,
+     * ensuring consistent logic across all subscription scenarios.
+     *
+     * The record will be updated once the user subscribes via Stripe.
+     *
+     * @param userId - The user ID to initialize subscription for
+     * @returns The created placeholder subscription record
+     */
+    initializeSubscription(userId: string, tx?: Prisma.TransactionClient): Promise<Subscription>;
+    createSubscription(data: {
+        userId: string;
+        orderId: string;
+        paySubscriptionId?: string;
+        priceId?: string;
+        priceName?: string;
+        status?: string;
+        creditsAllocated: number;
+        subPeriodStart?: Date;
+        subPeriodEnd?: Date;
+    }, tx?: Prisma.TransactionClient): Promise<Subscription>;
+    findByPaySubscriptionId(paySubscriptionId: string, tx?: Prisma.TransactionClient): Promise<Subscription | null>;
+    getActiveSubscription(userId: string, tx?: Prisma.TransactionClient): Promise<Subscription | null>;
+    getNonActiveSubscription(userId: string, tx?: Prisma.TransactionClient): Promise<Subscription | null>;
+    updateSubscription(id: bigint, data: Prisma.SubscriptionUpdateInput, tx?: Prisma.TransactionClient): Promise<Subscription>;
+    updateStatus(id: bigint, status: string, tx?: Prisma.TransactionClient): Promise<Subscription>;
+    updatePeriod(id: bigint, subPeriodStart: Date, subPeriodEnd: Date, tx?: Prisma.TransactionClient): Promise<Subscription>;
+    cancelSubscription(id: bigint, cancelAtPeriodEnd?: boolean, tx?: Prisma.TransactionClient): Promise<Subscription>;
+    renewSubscription(id: bigint, newPeriodEnd: Date, creditsToAdd?: number, tx?: Prisma.TransactionClient): Promise<Subscription>;
+    deleteSubscription(id: bigint, tx?: Prisma.TransactionClient): Promise<void>;
+    getExpiringSubscriptions(days?: number, tx?: Prisma.TransactionClient): Promise<Subscription[]>;
+    getExpiredSubscriptions(tx?: Prisma.TransactionClient): Promise<Subscription[]>;
+    updateExpiredSubscriptions(tx?: Prisma.TransactionClient): Promise<number>;
+    getSubscriptionStats(tx?: Prisma.TransactionClient): Promise<{
+        total: number;
+        active: number;
+        canceled: number;
+        pastDue: number;
+        incomplete: number;
+        trialing: number;
+        revenue: number;
+    }>;
+}
+export declare const subscriptionService: SubscriptionService;
+//# sourceMappingURL=subscription.service.d.ts.map

package/dist/services/database/subscription.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription.service.d.ts","sourceRoot":"","sources":["../../../src/services/database/subscription.service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEhE,qBAAa,mBAAmB;IAE9B;;;;;;;;;OASG;IACG,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC;IAa5F,kBAAkB,CAAC,IAAI,EAAE;QAC7B,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,gBAAgB,EAAE,MAAM,CAAC;QACzB,cAAc,CAAC,EAAE,IAAI,CAAC;QACtB,YAAY,CAAC,EAAE,IAAI,CAAC;KACrB,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC;IAmBlD,uBAAuB,CAC3B,iBAAiB,EAAE,MAAM,EACzB,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAC5B,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IASzB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAYlG,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAcrG,kBAAkB,CACtB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,CAAC,uBAAuB,EACpC,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAC5B,OAAO,CAAC,YAAY,CAAC;IAUlB,YAAY,CAChB,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAC5B,OAAO,CAAC,YAAY,CAAC;IAUlB,YAAY,CAChB,EAAE,EAAE,MAAM,EACV,cAAc,EAAE,IAAI,EACpB,YAAY,EAAE,IAAI,EAClB,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAC5B,OAAO,CAAC,YAAY,CAAC;IAalB,kBAAkB,CACtB,EAAE,EAAE,MAAM,EACV,iBAAiB,GAAE,OAAc,EACjC,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAC5B,OAAO,CAAC,YAAY,CAAC;IAkBlB,iBAAiB,CACrB,EAAE,EAAE,MAAM,EACV,YAAY,EAAE,IAAI,EAClB,YAAY,CAAC,EAAE,MAAM,EACrB,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAC5B,OAAO,CAAC,YAAY,CAAC;IAyBlB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAU5E,wBAAwB,CAAC,IAAI,GAAE,MAAU,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAoBlG,uBAAuB,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAe/E,0BAA0B,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAoB1E,oBAAoB,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,iBAAiB,GAAG,OAAO,CAAC;QACjE,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CAiDH;AAED,eAAO,MAAM,mBAAmB,qBAA4B,CAAC"}

package/dist/services/database/subscription.service.js

@@ -0,0 +1,267 @@
+'use strict';
+
+var tslib_es6 = require('../../node_modules/.pnpm/@rollup_plugin-typescript@12.1.4_rollup@4.46.2_tslib@2.8.1_typescript@5.9.3/node_modules/tslib/tslib.es6.js');
+var constants = require('./constants.js');
+var prisma = require('../../prisma/prisma.js');
+
+class SubscriptionService {
+    /**
+     * Initialize a placeholder subscription record for new users
+     * This allows Stripe webhook handlers to UPDATE instead of CREATE,
+     * ensuring consistent logic across all subscription scenarios.
+     *
+     * The record will be updated once the user subscribes via Stripe.
+     *
+     * @param userId - The user ID to initialize subscription for
+     * @returns The created placeholder subscription record
+     */
+    initializeSubscription(userId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.create({
+                data: {
+                    userId,
+                    status: constants.SubscriptionStatus.INCOMPLETE,
+                    creditsAllocated: 0,
+                },
+            });
+        });
+    }
+    // Create a new subscription
+    createSubscription(data, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.create({
+                data: {
+                    userId: data.userId,
+                    orderId: data.orderId,
+                    paySubscriptionId: data.paySubscriptionId,
+                    priceId: data.priceId,
+                    priceName: data.priceName,
+                    status: data.status || constants.SubscriptionStatus.INCOMPLETE,
+                    creditsAllocated: data.creditsAllocated,
+                    subPeriodStart: data.subPeriodStart,
+                    subPeriodEnd: data.subPeriodEnd,
+                }
+            });
+        });
+    }
+    // Find subscription by pay subscription ID
+    findByPaySubscriptionId(paySubscriptionId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findFirst({
+                where: { paySubscriptionId, deleted: 0 }
+            });
+        });
+    }
+    // Get user's active subscription
+    getActiveSubscription(userId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findUnique({
+                where: {
+                    userId,
+                    status: constants.SubscriptionStatus.ACTIVE,
+                    deleted: 0
+                }
+            });
+        });
+    }
+    getNonActiveSubscription(userId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findUnique({
+                where: {
+                    userId,
+                    status: { not: constants.SubscriptionStatus.ACTIVE },
+                    deleted: 0
+                }
+            });
+        });
+    }
+    // Update subscription
+    updateSubscription(id, data, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.update({
+                where: { id },
+                data,
+            });
+        });
+    }
+    // Update subscription status
+    updateStatus(id, status, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.update({
+                where: { id },
+                data: { status },
+            });
+        });
+    }
+    // Update subscription period
+    updatePeriod(id, subPeriodStart, subPeriodEnd, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.update({
+                where: { id },
+                data: {
+                    subPeriodStart,
+                    subPeriodEnd,
+                },
+            });
+        });
+    }
+    // Cancel subscription
+    cancelSubscription(id_1) {
+        return tslib_es6.__awaiter(this, arguments, void 0, function* (id, cancelAtPeriodEnd = true, tx) {
+            const updateData = {
+                status: constants.SubscriptionStatus.CANCELED,
+            };
+            if (!cancelAtPeriodEnd) {
+                updateData.subPeriodEnd = new Date();
+            }
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.update({
+                where: { id },
+                data: updateData,
+            });
+        });
+    }
+    // Renew subscription
+    renewSubscription(id, newPeriodEnd, creditsToAdd, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            const subscription = yield client.subscription.findFirst({
+                where: { id },
+            });
+            if (!subscription) {
+                throw new Error('Subscription not found');
+            }
+            return yield client.subscription.update({
+                where: { id },
+                data: {
+                    status: constants.SubscriptionStatus.ACTIVE,
+                    subPeriodStart: subscription.subPeriodEnd || new Date(),
+                    subPeriodEnd: newPeriodEnd,
+                    creditsAllocated: creditsToAdd
+                        ? subscription.creditsAllocated + creditsToAdd
+                        : subscription.creditsAllocated,
+                },
+            });
+        });
+    }
+    // Soft Delete subscription
+    deleteSubscription(id, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            yield client.subscription.update({
+                where: { id },
+                data: { deleted: 1, status: constants.SubscriptionStatus.INCOMPLETE },
+            });
+        });
+    }
+    // Get expiring subscriptions (within 7 days)
+    getExpiringSubscriptions() {
+        return tslib_es6.__awaiter(this, arguments, void 0, function* (days = 7, tx) {
+            const now = new Date();
+            const expiryDate = new Date();
+            expiryDate.setDate(expiryDate.getDate() + days);
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findMany({
+                where: {
+                    status: constants.SubscriptionStatus.ACTIVE,
+                    deleted: 0,
+                    subPeriodEnd: {
+                        gte: now,
+                        lte: expiryDate,
+                    },
+                }
+            });
+        });
+    }
+    // Get expired subscriptions
+    getExpiredSubscriptions(tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findMany({
+                where: {
+                    status: constants.SubscriptionStatus.ACTIVE,
+                    deleted: 0,
+                    subPeriodEnd: {
+                        lt: new Date(),
+                    },
+                }
+            });
+        });
+    }
+    // Update expired subscriptions status
+    updateExpiredSubscriptions(tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            const result = yield client.subscription.updateMany({
+                where: {
+                    status: constants.SubscriptionStatus.ACTIVE,
+                    deleted: 0,
+                    subPeriodEnd: {
+                        lt: new Date(),
+                    },
+                },
+                data: {
+                    status: constants.SubscriptionStatus.PAST_DUE,
+                },
+            });
+            return result.count;
+        });
+    }
+    // Get subscription statistics
+    getSubscriptionStats(tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            const [total, active, canceled, pastDue, incomplete, trialing] = yield Promise.all([
+                client.subscription.count({ where: { deleted: 0 } }),
+                client.subscription.count({
+                    where: { status: constants.SubscriptionStatus.ACTIVE, deleted: 0 }
+                }),
+                client.subscription.count({
+                    where: { status: constants.SubscriptionStatus.CANCELED, deleted: 0 }
+                }),
+                client.subscription.count({
+                    where: { status: constants.SubscriptionStatus.PAST_DUE, deleted: 0 }
+                }),
+                client.subscription.count({
+                    where: { status: constants.SubscriptionStatus.INCOMPLETE, deleted: 0 }
+                }),
+                client.subscription.count({
+                    where: { status: constants.SubscriptionStatus.TRIALING, deleted: 0 }
+                }),
+            ]);
+            // Calculate active subscription revenue (need to combine with transaction table)
+            const activeSubscriptions = yield client.subscription.findMany({
+                where: { status: constants.SubscriptionStatus.ACTIVE, deleted: 0 },
+                select: { paySubscriptionId: true },
+            });
+            let revenue = 0;
+            if (activeSubscriptions.length > 0) {
+                const transactions = yield client.transaction.findMany({
+                    where: {
+                        paySubscriptionId: {
+                            in: activeSubscriptions
+                                .map(s => s.paySubscriptionId)
+                                .filter(Boolean),
+                        },
+                        orderStatus: 'success',
+                    },
+                    select: { amount: true },
+                });
+                revenue = transactions.reduce((sum, t) => sum + (t.amount ? parseFloat(t.amount.toString()) : 0), 0);
+            }
+            return { total, active, canceled, pastDue, incomplete, trialing, revenue };
+        });
+    }
+}
+const subscriptionService = new SubscriptionService();
+
+exports.SubscriptionService = SubscriptionService;
+exports.subscriptionService = subscriptionService;

package/dist/services/database/subscription.service.mjs

@@ -0,0 +1,264 @@
+import { __awaiter } from '../../node_modules/.pnpm/@rollup_plugin-typescript@12.1.4_rollup@4.46.2_tslib@2.8.1_typescript@5.9.3/node_modules/tslib/tslib.es6.mjs';
+import { SubscriptionStatus } from './constants.mjs';
+import { checkAndFallbackWithNonTCClient } from '../../prisma/prisma.mjs';
+
+class SubscriptionService {
+    /**
+     * Initialize a placeholder subscription record for new users
+     * This allows Stripe webhook handlers to UPDATE instead of CREATE,
+     * ensuring consistent logic across all subscription scenarios.
+     *
+     * The record will be updated once the user subscribes via Stripe.
+     *
+     * @param userId - The user ID to initialize subscription for
+     * @returns The created placeholder subscription record
+     */
+    initializeSubscription(userId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.create({
+                data: {
+                    userId,
+                    status: SubscriptionStatus.INCOMPLETE,
+                    creditsAllocated: 0,
+                },
+            });
+        });
+    }
+    // Create a new subscription
+    createSubscription(data, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.create({
+                data: {
+                    userId: data.userId,
+                    orderId: data.orderId,
+                    paySubscriptionId: data.paySubscriptionId,
+                    priceId: data.priceId,
+                    priceName: data.priceName,
+                    status: data.status || SubscriptionStatus.INCOMPLETE,
+                    creditsAllocated: data.creditsAllocated,
+                    subPeriodStart: data.subPeriodStart,
+                    subPeriodEnd: data.subPeriodEnd,
+                }
+            });
+        });
+    }
+    // Find subscription by pay subscription ID
+    findByPaySubscriptionId(paySubscriptionId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findFirst({
+                where: { paySubscriptionId, deleted: 0 }
+            });
+        });
+    }
+    // Get user's active subscription
+    getActiveSubscription(userId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findUnique({
+                where: {
+                    userId,
+                    status: SubscriptionStatus.ACTIVE,
+                    deleted: 0
+                }
+            });
+        });
+    }
+    getNonActiveSubscription(userId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findUnique({
+                where: {
+                    userId,
+                    status: { not: SubscriptionStatus.ACTIVE },
+                    deleted: 0
+                }
+            });
+        });
+    }
+    // Update subscription
+    updateSubscription(id, data, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.update({
+                where: { id },
+                data,
+            });
+        });
+    }
+    // Update subscription status
+    updateStatus(id, status, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.update({
+                where: { id },
+                data: { status },
+            });
+        });
+    }
+    // Update subscription period
+    updatePeriod(id, subPeriodStart, subPeriodEnd, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.update({
+                where: { id },
+                data: {
+                    subPeriodStart,
+                    subPeriodEnd,
+                },
+            });
+        });
+    }
+    // Cancel subscription
+    cancelSubscription(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, cancelAtPeriodEnd = true, tx) {
+            const updateData = {
+                status: SubscriptionStatus.CANCELED,
+            };
+            if (!cancelAtPeriodEnd) {
+                updateData.subPeriodEnd = new Date();
+            }
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.update({
+                where: { id },
+                data: updateData,
+            });
+        });
+    }
+    // Renew subscription
+    renewSubscription(id, newPeriodEnd, creditsToAdd, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            const subscription = yield client.subscription.findFirst({
+                where: { id },
+            });
+            if (!subscription) {
+                throw new Error('Subscription not found');
+            }
+            return yield client.subscription.update({
+                where: { id },
+                data: {
+                    status: SubscriptionStatus.ACTIVE,
+                    subPeriodStart: subscription.subPeriodEnd || new Date(),
+                    subPeriodEnd: newPeriodEnd,
+                    creditsAllocated: creditsToAdd
+                        ? subscription.creditsAllocated + creditsToAdd
+                        : subscription.creditsAllocated,
+                },
+            });
+        });
+    }
+    // Soft Delete subscription
+    deleteSubscription(id, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            yield client.subscription.update({
+                where: { id },
+                data: { deleted: 1, status: SubscriptionStatus.INCOMPLETE },
+            });
+        });
+    }
+    // Get expiring subscriptions (within 7 days)
+    getExpiringSubscriptions() {
+        return __awaiter(this, arguments, void 0, function* (days = 7, tx) {
+            const now = new Date();
+            const expiryDate = new Date();
+            expiryDate.setDate(expiryDate.getDate() + days);
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findMany({
+                where: {
+                    status: SubscriptionStatus.ACTIVE,
+                    deleted: 0,
+                    subPeriodEnd: {
+                        gte: now,
+                        lte: expiryDate,
+                    },
+                }
+            });
+        });
+    }
+    // Get expired subscriptions
+    getExpiredSubscriptions(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.subscription.findMany({
+                where: {
+                    status: SubscriptionStatus.ACTIVE,
+                    deleted: 0,
+                    subPeriodEnd: {
+                        lt: new Date(),
+                    },
+                }
+            });
+        });
+    }
+    // Update expired subscriptions status
+    updateExpiredSubscriptions(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            const result = yield client.subscription.updateMany({
+                where: {
+                    status: SubscriptionStatus.ACTIVE,
+                    deleted: 0,
+                    subPeriodEnd: {
+                        lt: new Date(),
+                    },
+                },
+                data: {
+                    status: SubscriptionStatus.PAST_DUE,
+                },
+            });
+            return result.count;
+        });
+    }
+    // Get subscription statistics
+    getSubscriptionStats(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            const [total, active, canceled, pastDue, incomplete, trialing] = yield Promise.all([
+                client.subscription.count({ where: { deleted: 0 } }),
+                client.subscription.count({
+                    where: { status: SubscriptionStatus.ACTIVE, deleted: 0 }
+                }),
+                client.subscription.count({
+                    where: { status: SubscriptionStatus.CANCELED, deleted: 0 }
+                }),
+                client.subscription.count({
+                    where: { status: SubscriptionStatus.PAST_DUE, deleted: 0 }
+                }),
+                client.subscription.count({
+                    where: { status: SubscriptionStatus.INCOMPLETE, deleted: 0 }
+                }),
+                client.subscription.count({
+                    where: { status: SubscriptionStatus.TRIALING, deleted: 0 }
+                }),
+            ]);
+            // Calculate active subscription revenue (need to combine with transaction table)
+            const activeSubscriptions = yield client.subscription.findMany({
+                where: { status: SubscriptionStatus.ACTIVE, deleted: 0 },
+                select: { paySubscriptionId: true },
+            });
+            let revenue = 0;
+            if (activeSubscriptions.length > 0) {
+                const transactions = yield client.transaction.findMany({
+                    where: {
+                        paySubscriptionId: {
+                            in: activeSubscriptions
+                                .map(s => s.paySubscriptionId)
+                                .filter(Boolean),
+                        },
+                        orderStatus: 'success',
+                    },
+                    select: { amount: true },
+                });
+                revenue = transactions.reduce((sum, t) => sum + (t.amount ? parseFloat(t.amount.toString()) : 0), 0);
+            }
+            return { total, active, canceled, pastDue, incomplete, trialing, revenue };
+        });
+    }
+}
+const subscriptionService = new SubscriptionService();
+
+export { SubscriptionService, subscriptionService };

package/dist/services/database/transaction.service.d.ts

@@ -0,0 +1,92 @@
+import { Prisma } from './prisma-model-type';
+import type { Transaction } from './prisma-model-type';
+import { PaySupplier } from './constants';
+export declare class TransactionService {
+    createTransaction(data: {
+        userId: string;
+        orderId: string;
+        orderStatus?: string;
+        paymentStatus?: string;
+        paySupplier?: PaySupplier;
+        payTransactionId?: string;
+        paySubscriptionId?: string;
+        subPeriodStart?: Date;
+        subPeriodEnd?: Date;
+        paySessionId?: string;
+        payInvoiceId?: string;
+        hostedInvoiceUrl?: string;
+        invoicePdf?: string;
+        billingReason?: string;
+        priceId?: string;
+        priceName?: string;
+        amount?: number;
+        currency?: string;
+        type?: string;
+        creditsGranted?: number;
+        orderDetail?: string;
+        orderExpiredAt?: Date;
+        paidAt?: Date;
+        paidEmail: string | null;
+        payUpdatedAt?: Date;
+    }, tx?: Prisma.TransactionClient): Promise<Transaction>;
+    findByOrderId(orderId: string, tx?: Prisma.TransactionClient): Promise<Transaction | null>;
+    findByPaySessionId(paySessionId: string, tx?: Prisma.TransactionClient): Promise<Transaction | null>;
+    findByPayTransactionId(payTransactionId: string, tx?: Prisma.TransactionClient): Promise<Transaction | null>;
+    findByUserId(userId: string, params?: {
+        orderStatus?: string;
+        type?: string;
+        skip?: number;
+        take?: number;
+        orderBy?: Prisma.TransactionOrderByWithRelationInput;
+    }, tx?: Prisma.TransactionClient): Promise<{
+        transactions: Transaction[];
+        total: number;
+    }>;
+    updateStatus(orderId: string, orderStatus: string, additionalData?: {
+        payTransactionId?: string;
+        paidAt?: Date;
+        paidEmail?: string;
+        paidDetail?: string;
+        payUpdatedAt?: Date;
+        paymentStatus?: string;
+        paySubscriptionId?: string;
+        paySessionId?: string;
+        payInvoiceId?: string;
+        hostedInvoiceUrl?: string;
+        invoicePdf?: string;
+        billingReason?: string;
+        orderDetail?: string;
+    }, tx?: Prisma.TransactionClient): Promise<Transaction>;
+    update(orderId: string, data: Prisma.TransactionUpdateInput, tx?: Prisma.TransactionClient): Promise<Transaction>;
+    completePayment(orderId: string, paymentData: {
+        payTransactionId?: string;
+        paidAt: Date;
+        paidEmail?: string;
+        paidDetail?: string;
+        creditsGranted?: number;
+        payUpdatedAt?: Date;
+        paymentStatus?: string;
+    }, tx?: Prisma.TransactionClient): Promise<Transaction>;
+    processRefund(orderId: string, refundData: {
+        refundAmount?: number;
+        refundReason?: string;
+        refundedAt?: Date;
+    }, tx?: Prisma.TransactionClient): Promise<Transaction>;
+    cancelOrder(orderId: string, reason?: string, tx?: Prisma.TransactionClient): Promise<Transaction>;
+    getExpiredOrders(tx?: Prisma.TransactionClient): Promise<Transaction[]>;
+    updateExpiredOrders(tx?: Prisma.TransactionClient): Promise<number>;
+    getSubscriptionTransactions(paySubscriptionId: string, tx?: Prisma.TransactionClient): Promise<Transaction[]>;
+    getRevenueStats(startDate?: Date, endDate?: Date, tx?: Prisma.TransactionClient): Promise<{
+        totalRevenue: number;
+        totalTransactions: number;
+        averageOrderValue: number;
+        subscriptionRevenue: number;
+        oneTimeRevenue: number;
+        refundedAmount: number;
+    }>;
+    getDailyRevenue(days?: number, tx?: Prisma.TransactionClient): Promise<any[]>;
+    deleteTransaction(orderId: string, tx?: Prisma.TransactionClient): Promise<void>;
+    createBatchTransactions(transactions: Prisma.TransactionCreateManyInput[], tx?: Prisma.TransactionClient): Promise<number>;
+}
+export declare const transactionService: TransactionService;
+//# sourceMappingURL=transaction.service.d.ts.map