@windrun-huaiin/backend-core 10.0.1

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

@@ -0,0 +1,249 @@
+'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 prisma = require('../../prisma/prisma.js');
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class UserBackupService {
+    // Create user backup
+    createBackup(data, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.create({
+                data: {
+                    originalUserId: data.originalUserId,
+                    fingerprintId: data.fingerprintId,
+                    clerkUserId: data.clerkUserId,
+                    stripeCusId: data.stripeCusId,
+                    email: data.email,
+                    userName: data.userName,
+                    status: data.status,
+                    backupData: data.backupData,
+                },
+            });
+        });
+    }
+    // Backup user basic data
+    backupUserData(userId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            // Get user basic data
+            const userData = yield client.user.findUnique({
+                where: { userId },
+            });
+            if (!userData) {
+                throw new Error('User not found');
+            }
+            // Create backup record
+            return yield this.createBackup({
+                originalUserId: userData.userId,
+                fingerprintId: userData.fingerprintId || undefined,
+                clerkUserId: userData.clerkUserId || undefined,
+                email: userData.email || undefined,
+                status: userData.status,
+                backupData: {
+                    id: userData.id.toString(),
+                    userId: userData.userId,
+                    fingerprintId: userData.fingerprintId,
+                    clerkUserId: userData.clerkUserId,
+                    email: userData.email,
+                    status: userData.status,
+                    createdAt: (_a = userData.createdAt) === null || _a === void 0 ? void 0 : _a.toISOString(),
+                    updatedAt: (_b = userData.updatedAt) === null || _b === void 0 ? void 0 : _b.toISOString(),
+                },
+            }, tx);
+        });
+    }
+    // Find backup by original user ID
+    findByOriginalUserId(originalUserId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findMany({
+                where: { originalUserId, deleted: 0 },
+                orderBy: { deletedAt: 'desc' },
+            });
+        });
+    }
+    // Find backup by email
+    findByEmail(email, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findMany({
+                where: { email, deleted: 0 },
+                orderBy: { deletedAt: 'desc' },
+            });
+        });
+    }
+    // Find backup by Fingerprint ID
+    findByFingerprintId(fingerprintId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findMany({
+                where: { fingerprintId, deleted: 0 },
+                orderBy: { deletedAt: 'desc' },
+            });
+        });
+    }
+    // Find backup by Clerk user ID
+    findByClerkUserId(clerkUserId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findMany({
+                where: { clerkUserId, deleted: 0 },
+                orderBy: { deletedAt: 'desc' },
+            });
+        });
+    }
+    // Find backup by backup ID
+    getBackupById(id, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findFirst({
+                where: { id, deleted: 0 },
+            });
+        });
+    }
+    // Restore user data from backup
+    restoreUserData(backupId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const backup = yield this.getBackupById(backupId, tx);
+            if (!backup) {
+                throw new Error('Backup not found');
+            }
+            const backupData = backup.backupData;
+            if (!backupData) {
+                throw new Error('No backup data available');
+            }
+            const restore = (client) => tslib_es6.__awaiter(this, void 0, void 0, function* () {
+                const user = yield client.user.create({
+                    data: {
+                        fingerprintId: backupData.fingerprintId,
+                        clerkUserId: backupData.clerkUserId,
+                        email: backupData.email,
+                        status: backupData.status,
+                    },
+                });
+                return {
+                    user,
+                };
+            });
+            return restore(prisma.checkAndFallbackWithNonTCClient(tx));
+        });
+    }
+    // List backups
+    listBackups(params, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            const where = { deleted: 0 };
+            if (params.startDate || params.endDate) {
+                where.deletedAt = {};
+                if (params.startDate)
+                    where.deletedAt.gte = params.startDate;
+                if (params.endDate)
+                    where.deletedAt.lte = params.endDate;
+            }
+            const [backups, total] = yield Promise.all([
+                client.userBackup.findMany({
+                    where,
+                    skip: params.skip || 0,
+                    take: params.take || 20,
+                    orderBy: params.orderBy || { deletedAt: 'desc' },
+                }),
+                client.userBackup.count({ where }),
+            ]);
+            return { backups, total };
+        });
+    }
+    // Soft Delete old backups (data cleanup)
+    deleteOldBackups() {
+        return tslib_es6.__awaiter(this, arguments, void 0, function* (daysToKeep = 90, tx) {
+            const cutoffDate = new Date();
+            cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            const result = yield client.userBackup.updateMany({
+                where: {
+                    deletedAt: {
+                        lt: cutoffDate,
+                    },
+                    deleted: 0,
+                },
+                data: {
+                    deleted: 1,
+                },
+            });
+            return result.count;
+        });
+    }
+    // Get backup statistics
+    getBackupStats(tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const client = prisma.checkAndFallbackWithNonTCClient(tx);
+            const now = new Date();
+            const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+            const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+            const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+            const [totalBackups, last24Hours, last7Days, last30Days,] = yield Promise.all([
+                client.userBackup.count({ where: { deleted: 0 } }),
+                client.userBackup.count({
+                    where: { deletedAt: { gte: oneDayAgo }, deleted: 0 },
+                }),
+                client.userBackup.count({
+                    where: { deletedAt: { gte: sevenDaysAgo }, deleted: 0 },
+                }),
+                client.userBackup.count({
+                    where: { deletedAt: { gte: thirtyDaysAgo }, deleted: 0 },
+                }),
+            ]);
+            // Calculate average backup size (simplified calculation)
+            const sampleBackups = yield client.userBackup.findMany({
+                where: { deleted: 0 },
+                take: 100,
+                select: { backupData: true },
+            });
+            const avgBackupSize = sampleBackups.length > 0
+                ? sampleBackups.reduce((sum, backup) => {
+                    const size = JSON.stringify(backup.backupData || {}).length;
+                    return sum + size;
+                }, 0) / sampleBackups.length
+                : 0;
+            return {
+                totalBackups,
+                last24Hours,
+                last7Days,
+                last30Days,
+                avgBackupSize: Math.round(avgBackupSize),
+            };
+        });
+    }
+    // Export backup data as JSON
+    exportBackup(backupId, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            const backup = yield this.getBackupById(backupId, tx);
+            if (!backup) {
+                throw new Error('Backup not found');
+            }
+            return JSON.stringify(backup, null, 2);
+        });
+    }
+    // Batch backup users (for scheduled backup tasks)
+    batchBackupUsers(userIds, tx) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            let successCount = 0;
+            for (const userId of userIds) {
+                try {
+                    yield this.backupUserData(userId, tx);
+                    successCount++;
+                }
+                catch (error) {
+                    console.error(`Failed to backup user ${userId}:`, error);
+                }
+            }
+            return successCount;
+        });
+    }
+}
+const userBackupService = new UserBackupService();
+
+exports.UserBackupService = UserBackupService;
+exports.userBackupService = userBackupService;

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

@@ -0,0 +1,246 @@
+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 { checkAndFallbackWithNonTCClient } from '../../prisma/prisma.mjs';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class UserBackupService {
+    // Create user backup
+    createBackup(data, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.create({
+                data: {
+                    originalUserId: data.originalUserId,
+                    fingerprintId: data.fingerprintId,
+                    clerkUserId: data.clerkUserId,
+                    stripeCusId: data.stripeCusId,
+                    email: data.email,
+                    userName: data.userName,
+                    status: data.status,
+                    backupData: data.backupData,
+                },
+            });
+        });
+    }
+    // Backup user basic data
+    backupUserData(userId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const client = checkAndFallbackWithNonTCClient(tx);
+            // Get user basic data
+            const userData = yield client.user.findUnique({
+                where: { userId },
+            });
+            if (!userData) {
+                throw new Error('User not found');
+            }
+            // Create backup record
+            return yield this.createBackup({
+                originalUserId: userData.userId,
+                fingerprintId: userData.fingerprintId || undefined,
+                clerkUserId: userData.clerkUserId || undefined,
+                email: userData.email || undefined,
+                status: userData.status,
+                backupData: {
+                    id: userData.id.toString(),
+                    userId: userData.userId,
+                    fingerprintId: userData.fingerprintId,
+                    clerkUserId: userData.clerkUserId,
+                    email: userData.email,
+                    status: userData.status,
+                    createdAt: (_a = userData.createdAt) === null || _a === void 0 ? void 0 : _a.toISOString(),
+                    updatedAt: (_b = userData.updatedAt) === null || _b === void 0 ? void 0 : _b.toISOString(),
+                },
+            }, tx);
+        });
+    }
+    // Find backup by original user ID
+    findByOriginalUserId(originalUserId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findMany({
+                where: { originalUserId, deleted: 0 },
+                orderBy: { deletedAt: 'desc' },
+            });
+        });
+    }
+    // Find backup by email
+    findByEmail(email, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findMany({
+                where: { email, deleted: 0 },
+                orderBy: { deletedAt: 'desc' },
+            });
+        });
+    }
+    // Find backup by Fingerprint ID
+    findByFingerprintId(fingerprintId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findMany({
+                where: { fingerprintId, deleted: 0 },
+                orderBy: { deletedAt: 'desc' },
+            });
+        });
+    }
+    // Find backup by Clerk user ID
+    findByClerkUserId(clerkUserId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findMany({
+                where: { clerkUserId, deleted: 0 },
+                orderBy: { deletedAt: 'desc' },
+            });
+        });
+    }
+    // Find backup by backup ID
+    getBackupById(id, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            return yield client.userBackup.findFirst({
+                where: { id, deleted: 0 },
+            });
+        });
+    }
+    // Restore user data from backup
+    restoreUserData(backupId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const backup = yield this.getBackupById(backupId, tx);
+            if (!backup) {
+                throw new Error('Backup not found');
+            }
+            const backupData = backup.backupData;
+            if (!backupData) {
+                throw new Error('No backup data available');
+            }
+            const restore = (client) => __awaiter(this, void 0, void 0, function* () {
+                const user = yield client.user.create({
+                    data: {
+                        fingerprintId: backupData.fingerprintId,
+                        clerkUserId: backupData.clerkUserId,
+                        email: backupData.email,
+                        status: backupData.status,
+                    },
+                });
+                return {
+                    user,
+                };
+            });
+            return restore(checkAndFallbackWithNonTCClient(tx));
+        });
+    }
+    // List backups
+    listBackups(params, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            const where = { deleted: 0 };
+            if (params.startDate || params.endDate) {
+                where.deletedAt = {};
+                if (params.startDate)
+                    where.deletedAt.gte = params.startDate;
+                if (params.endDate)
+                    where.deletedAt.lte = params.endDate;
+            }
+            const [backups, total] = yield Promise.all([
+                client.userBackup.findMany({
+                    where,
+                    skip: params.skip || 0,
+                    take: params.take || 20,
+                    orderBy: params.orderBy || { deletedAt: 'desc' },
+                }),
+                client.userBackup.count({ where }),
+            ]);
+            return { backups, total };
+        });
+    }
+    // Soft Delete old backups (data cleanup)
+    deleteOldBackups() {
+        return __awaiter(this, arguments, void 0, function* (daysToKeep = 90, tx) {
+            const cutoffDate = new Date();
+            cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+            const client = checkAndFallbackWithNonTCClient(tx);
+            const result = yield client.userBackup.updateMany({
+                where: {
+                    deletedAt: {
+                        lt: cutoffDate,
+                    },
+                    deleted: 0,
+                },
+                data: {
+                    deleted: 1,
+                },
+            });
+            return result.count;
+        });
+    }
+    // Get backup statistics
+    getBackupStats(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = checkAndFallbackWithNonTCClient(tx);
+            const now = new Date();
+            const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+            const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+            const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+            const [totalBackups, last24Hours, last7Days, last30Days,] = yield Promise.all([
+                client.userBackup.count({ where: { deleted: 0 } }),
+                client.userBackup.count({
+                    where: { deletedAt: { gte: oneDayAgo }, deleted: 0 },
+                }),
+                client.userBackup.count({
+                    where: { deletedAt: { gte: sevenDaysAgo }, deleted: 0 },
+                }),
+                client.userBackup.count({
+                    where: { deletedAt: { gte: thirtyDaysAgo }, deleted: 0 },
+                }),
+            ]);
+            // Calculate average backup size (simplified calculation)
+            const sampleBackups = yield client.userBackup.findMany({
+                where: { deleted: 0 },
+                take: 100,
+                select: { backupData: true },
+            });
+            const avgBackupSize = sampleBackups.length > 0
+                ? sampleBackups.reduce((sum, backup) => {
+                    const size = JSON.stringify(backup.backupData || {}).length;
+                    return sum + size;
+                }, 0) / sampleBackups.length
+                : 0;
+            return {
+                totalBackups,
+                last24Hours,
+                last7Days,
+                last30Days,
+                avgBackupSize: Math.round(avgBackupSize),
+            };
+        });
+    }
+    // Export backup data as JSON
+    exportBackup(backupId, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const backup = yield this.getBackupById(backupId, tx);
+            if (!backup) {
+                throw new Error('Backup not found');
+            }
+            return JSON.stringify(backup, null, 2);
+        });
+    }
+    // Batch backup users (for scheduled backup tasks)
+    batchBackupUsers(userIds, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let successCount = 0;
+            for (const userId of userIds) {
+                try {
+                    yield this.backupUserData(userId, tx);
+                    successCount++;
+                }
+                catch (error) {
+                    console.error(`Failed to backup user ${userId}:`, error);
+                }
+            }
+            return successCount;
+        });
+    }
+}
+const userBackupService = new UserBackupService();
+
+export { UserBackupService, userBackupService };

package/dist/services/stripe/index.d.ts

@@ -0,0 +1,2 @@
+export * from './webhook-handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/stripe/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/stripe/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/services/stripe/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var webhookHandler = require('./webhook-handler.js');
+
+
+
+exports.handleStripeEvent = webhookHandler.handleStripeEvent;

package/dist/services/stripe/index.mjs

@@ -0,0 +1 @@
+export { handleStripeEvent } from './webhook-handler.mjs';

package/dist/services/stripe/webhook-handler.d.ts

@@ -0,0 +1,6 @@
+import Stripe from 'stripe';
+/**
+ * Main event handler - routes events to specific handlers
+ */
+export declare function handleStripeEvent(event: Stripe.Event): Promise<void>;
+//# sourceMappingURL=webhook-handler.d.ts.map

package/dist/services/stripe/webhook-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-handler.d.ts","sourceRoot":"","sources":["../../../src/services/stripe/webhook-handler.ts"],"names":[],"mappings":"AAgBA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAoB5B;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,iBAqD1D"}