@goscribe/server 1.3.3 → 1.5.0

package/dist/services/admin/admin.service.js

@@ -0,0 +1,476 @@
+import { BaseService } from '../base.service.js';
+import { stripe } from '../../lib/stripe.js';
+import { buildActivityLogWhere, deleteActivityLogsOlderThan, getActivityRetentionDays, } from '../activity/activity-log.service.js';
+import { getActivityHumanDescription } from '../activity/activity-human-description.service.js';
+function csvEscapeCell(value) {
+    if (value === null || value === undefined)
+        return '';
+    const s = String(value);
+    if (/[",\n\r]/.test(s))
+        return `"${s.replace(/"/g, '""')}"`;
+    return s;
+}
+export class AdminService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async getSystemStats() {
+        const totalUsers = await this.db.user.count();
+        const totalWorkspaces = await this.db.workspace.count();
+        const totalSubscriptions = await this.db.subscription.count({
+            where: { status: 'active' },
+        });
+        const subRevenueResult = await this.db.invoice.aggregate({
+            where: { status: 'paid', type: 'SUBSCRIPTION' },
+            _sum: { amountPaid: true },
+        });
+        const topupRevenueResult = await this.db.invoice.aggregate({
+            where: { status: 'paid', type: 'TOPUP' },
+            _sum: { amountPaid: true },
+        });
+        const subRevenue = Number(subRevenueResult._sum.amountPaid || 0) / 100;
+        const topupRevenue = Number(topupRevenueResult._sum.amountPaid || 0) / 100;
+        return {
+            totalUsers,
+            totalWorkspaces,
+            totalSubscriptions,
+            revenue: subRevenue + topupRevenue,
+            subscriptionRevenue: subRevenue,
+            topupRevenue,
+        };
+    }
+    async listUsers(input) {
+        const search = input.search?.trim();
+        const baseRoleWhere = {
+            role: { name: { not: 'System Admin' } },
+        };
+        const searchWhere = search && search.length > 0
+            ? {
+                OR: [
+                    { email: { contains: search, mode: 'insensitive' } },
+                    { name: { contains: search, mode: 'insensitive' } },
+                    { id: { contains: search } },
+                ],
+            }
+            : undefined;
+        const verifiedWhere = input.emailVerified === 'yes'
+            ? { emailVerified: { not: null } }
+            : input.emailVerified === 'no'
+                ? { emailVerified: null }
+                : undefined;
+        const joinedWhere = input.joinedFrom || input.joinedTo
+            ? {
+                createdAt: {
+                    ...(input.joinedFrom ? { gte: input.joinedFrom } : {}),
+                    ...(input.joinedTo ? { lte: input.joinedTo } : {}),
+                },
+            }
+            : undefined;
+        const where = {
+            AND: [
+                baseRoleWhere,
+                ...(searchWhere ? [searchWhere] : []),
+                ...(verifiedWhere ? [verifiedWhere] : []),
+                ...(joinedWhere ? [joinedWhere] : []),
+            ],
+        };
+        const totalCount = await this.db.user.count({ where });
+        const pageSize = input.pageSize;
+        const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
+        const page = Math.min(Math.max(1, input.page), totalPages);
+        const skip = (page - 1) * pageSize;
+        const users = await this.db.user.findMany({
+            where,
+            skip,
+            take: pageSize,
+            orderBy: { createdAt: 'desc' },
+            include: {
+                role: true,
+                profilePicture: true,
+                subscriptions: {
+                    orderBy: { createdAt: 'desc' },
+                    take: 1,
+                    include: { plan: true },
+                },
+            },
+        });
+        return {
+            users: users.map((user) => ({
+                ...user,
+                profilePicture: user.profilePicture?.objectKey
+                    ? `/profile-picture/${user.profilePicture.objectKey}?t=${new Date(user.updatedAt).getTime()}`
+                    : null,
+            })),
+            page,
+            pageSize,
+            totalCount,
+            totalPages,
+        };
+    }
+    async listInvoices(input) {
+        const search = input.search?.trim();
+        const searchWhere = search && search.length > 0
+            ? {
+                OR: [
+                    { id: { contains: search } },
+                    { stripeInvoiceId: { contains: search, mode: 'insensitive' } },
+                    { user: { email: { contains: search, mode: 'insensitive' } } },
+                    { user: { name: { contains: search, mode: 'insensitive' } } },
+                ],
+            }
+            : undefined;
+        const userIdWhere = input.userId?.trim() ? { userId: input.userId.trim() } : undefined;
+        const statusWhere = input.status?.trim() ? { status: input.status.trim() } : undefined;
+        const typeWhere = input.type ? { type: input.type } : undefined;
+        const dateWhere = input.from || input.to
+            ? {
+                createdAt: {
+                    ...(input.from ? { gte: input.from } : {}),
+                    ...(input.to ? { lte: input.to } : {}),
+                },
+            }
+            : undefined;
+        const andParts = [
+            ...(searchWhere ? [searchWhere] : []),
+            ...(userIdWhere ? [userIdWhere] : []),
+            ...(statusWhere ? [statusWhere] : []),
+            ...(typeWhere ? [typeWhere] : []),
+            ...(dateWhere ? [dateWhere] : []),
+        ];
+        const where = andParts.length > 0 ? { AND: andParts } : {};
+        const totalCount = await this.db.invoice.count({ where });
+        const pageSize = input.pageSize;
+        const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
+        const page = Math.min(Math.max(1, input.page), totalPages);
+        const skip = (page - 1) * pageSize;
+        const invoices = await this.db.invoice.findMany({
+            where,
+            skip,
+            take: pageSize,
+            orderBy: { createdAt: 'desc' },
+            include: {
+                user: { include: { profilePicture: true } },
+                subscription: { include: { plan: true } },
+            },
+        });
+        const items = invoices.map((invoice) => ({
+            ...invoice,
+            user: invoice.user
+                ? {
+                    ...invoice.user,
+                    profilePicture: invoice.user.profilePicture?.objectKey
+                        ? `/profile-picture/${invoice.user.profilePicture.objectKey}?t=${new Date(invoice.user.updatedAt).getTime()}`
+                        : null,
+                }
+                : invoice.user,
+        }));
+        return { items, page, pageSize, totalCount, totalPages };
+    }
+    async listWorkspaces(input) {
+        const workspaces = await this.db.workspace.findMany({
+            take: input.limit + 1,
+            cursor: input.cursor ? { id: input.cursor } : undefined,
+            orderBy: { createdAt: 'desc' },
+            include: {
+                owner: { select: { name: true, email: true } },
+            },
+        });
+        let nextCursor = undefined;
+        if (workspaces.length > input.limit) {
+            const nextItem = workspaces.pop();
+            nextCursor = nextItem.id;
+        }
+        return { workspaces, nextCursor };
+    }
+    async updateUserRole(actorId, input) {
+        const role = await this.db.role.findUnique({ where: { name: input.roleName } });
+        if (!role) {
+            throw new Error(`Role ${input.roleName} not found`);
+        }
+        const updatedUser = await this.db.user.update({
+            where: { id: input.userId },
+            data: { roleId: role.id },
+        });
+        this.logger.info(`User ${input.userId} role updated to ${input.roleName} by admin ${actorId}`, 'ADMIN');
+        return updatedUser;
+    }
+    listPlans() {
+        return this.db.plan.findMany({
+            include: { limit: true },
+            orderBy: { price: 'asc' },
+        });
+    }
+    async upsertPlan(actorId, input) {
+        let { limits, id, stripePriceId, ...planData } = input;
+        if (!stripePriceId && !id) {
+            if (!stripe) {
+                throw new Error('Stripe is not configured on the server');
+            }
+            try {
+                const product = await stripe.products.create({
+                    name: planData.name,
+                    description: planData.description,
+                });
+                const price = await stripe.prices.create({
+                    product: product.id,
+                    unit_amount: Math.round(planData.price * 100),
+                    currency: 'usd',
+                    recurring: planData.type === 'subscription'
+                        ? { interval: planData.interval || 'month' }
+                        : undefined,
+                });
+                stripePriceId = price.id;
+                this.logger.info(`Automatically created Stripe Product (${product.id}) and Price (${price.id}) for plan: ${planData.name}`, 'STRIPE');
+            }
+            catch (err) {
+                this.logger.error(`Failed to automate Stripe creation: ${err.message}`, 'STRIPE');
+                throw new Error(`Stripe error: ${err.message}`);
+            }
+        }
+        if (id) {
+            const updatedPlan = await this.db.plan.update({
+                where: { id },
+                data: {
+                    ...planData,
+                    stripePriceId,
+                    limit: {
+                        update: {
+                            maxStorageBytes: BigInt(limits.maxStorageBytes),
+                            maxWorksheets: limits.maxWorksheets,
+                            maxFlashcards: limits.maxFlashcards,
+                            maxPodcasts: limits.maxPodcasts,
+                            maxStudyGuides: limits.maxStudyGuides,
+                        },
+                    },
+                },
+            });
+            this.logger.info(`Plan ${id} updated by admin ${actorId}`, 'ADMIN');
+            return updatedPlan;
+        }
+        const newPlan = await this.db.plan.create({
+            data: {
+                ...planData,
+                stripePriceId: stripePriceId || '',
+                limit: {
+                    create: {
+                        maxStorageBytes: BigInt(limits.maxStorageBytes),
+                        maxWorksheets: limits.maxWorksheets,
+                        maxFlashcards: limits.maxFlashcards,
+                        maxPodcasts: limits.maxPodcasts,
+                        maxStudyGuides: limits.maxStudyGuides,
+                    },
+                },
+            },
+        });
+        this.logger.info(`New plan ${newPlan.id} created by admin ${actorId}`, 'ADMIN');
+        return newPlan;
+    }
+    async deletePlan(actorId, id) {
+        const activeSubs = await this.db.subscription.count({
+            where: { planId: id, status: 'active' },
+        });
+        if (activeSubs > 0) {
+            await this.db.plan.update({ where: { id }, data: { active: false } });
+            return {
+                success: true,
+                message: 'Plan deactivated because it has active subscribers.',
+            };
+        }
+        await this.db.plan.delete({ where: { id } });
+        this.logger.info(`Plan ${id} deleted by admin ${actorId}`, 'ADMIN');
+        return { success: true, message: 'Plan deleted.' };
+    }
+    getUserInvoices(input) {
+        return this.db.invoice.findMany({
+            where: { userId: input.userId },
+            orderBy: { createdAt: 'desc' },
+            take: input.limit,
+            include: {
+                subscription: { include: { plan: true } },
+            },
+        });
+    }
+    async getUserDetailedInfo(userId) {
+        const user = await this.db.user.findUnique({
+            where: { id: userId },
+            include: {
+                role: true,
+                profilePicture: true,
+                subscriptions: {
+                    orderBy: { createdAt: 'desc' },
+                    take: 1,
+                    include: { plan: true },
+                },
+                _count: {
+                    select: { workspaces: true, artifacts: true },
+                },
+            },
+        });
+        if (!user)
+            throw new Error('User not found');
+        const totalSpentResult = await this.db.invoice.aggregate({
+            where: { userId, status: 'paid' },
+            _sum: { amountPaid: true },
+        });
+        const totalSpent = Number(totalSpentResult._sum.amountPaid || 0) / 100;
+        const purchasedCredits = await this.db.userCredit.groupBy({
+            by: ['resourceType'],
+            where: { userId },
+            _sum: { amount: true },
+        });
+        const profilePictureUrl = user.profilePicture?.objectKey
+            ? `/profile-picture/${user.profilePicture.objectKey}?t=${new Date(user.updatedAt).getTime()}`
+            : null;
+        return {
+            ...user,
+            totalSpent,
+            purchasedCredits: purchasedCredits.map((c) => ({
+                type: c.resourceType,
+                amount: c._sum.amount || 0,
+            })),
+            profilePicture: profilePictureUrl,
+        };
+    }
+    async debugInvoices() {
+        const count = await this.db.invoice.count();
+        const all = await this.db.invoice.findMany({ take: 10 });
+        return { count, all };
+    }
+    listResourcePrices() {
+        return this.db.resourcePrice.findMany({
+            orderBy: { resourceType: 'asc' },
+        });
+    }
+    async upsertResourcePrice(actorId, input) {
+        const price = await this.db.resourcePrice.upsert({
+            where: { resourceType: input.resourceType },
+            update: { priceCents: input.priceCents },
+            create: {
+                resourceType: input.resourceType,
+                priceCents: input.priceCents,
+            },
+        });
+        this.logger.info(`Resource price for ${input.resourceType} updated to ${input.priceCents} by admin ${actorId}`, 'ADMIN');
+        return price;
+    }
+    async listRecentInvoices(limit) {
+        const invoices = await this.db.invoice.findMany({
+            take: limit,
+            orderBy: { createdAt: 'desc' },
+            include: {
+                user: { include: { profilePicture: true } },
+            },
+        });
+        return invoices.map((invoice) => ({
+            ...invoice,
+            user: {
+                ...invoice.user,
+                profilePicture: invoice.user.profilePicture?.objectKey
+                    ? `/profile-picture/${invoice.user.profilePicture.objectKey}?t=${new Date(invoice.user.updatedAt).getTime()}`
+                    : null,
+            },
+        }));
+    }
+    async activityList(input) {
+        const where = buildActivityLogWhere({
+            from: input.from,
+            to: input.to,
+            actorUserId: input.actorUserId,
+            workspaceId: input.workspaceId,
+            category: input.category,
+            status: input.status,
+            search: input.search,
+        });
+        const totalCount = await this.db.activityLog.count({ where });
+        const totalPages = Math.max(1, Math.ceil(totalCount / input.limit));
+        const page = Math.min(Math.max(1, input.page), totalPages);
+        const skip = (page - 1) * input.limit;
+        const rows = await this.db.activityLog.findMany({
+            where,
+            skip,
+            take: input.limit,
+            orderBy: { createdAt: 'desc' },
+            include: {
+                actor: { select: { id: true, email: true, name: true } },
+                workspace: { select: { id: true, title: true } },
+            },
+        });
+        return {
+            items: rows.map((r) => ({
+                id: r.id,
+                createdAt: r.createdAt,
+                action: r.action,
+                description: getActivityHumanDescription(r.trpcPath, r.action),
+                category: r.category,
+                trpcPath: r.trpcPath,
+                status: r.status,
+                durationMs: r.durationMs,
+                errorCode: r.errorCode,
+                ipAddress: r.ipAddress,
+                actor: r.actor,
+                workspace: r.workspace,
+                metadata: r.metadata,
+            })),
+            page,
+            pageSize: input.limit,
+            totalCount,
+            totalPages,
+        };
+    }
+    async activityExportCsv(input) {
+        const where = buildActivityLogWhere({
+            from: input.from,
+            to: input.to,
+            actorUserId: input.actorUserId,
+            workspaceId: input.workspaceId,
+            category: input.category,
+            status: input.status,
+            search: input.search,
+        });
+        const rows = await this.db.activityLog.findMany({
+            where,
+            orderBy: { createdAt: 'desc' },
+            take: input.maxRows,
+            include: {
+                actor: { select: { email: true, name: true } },
+                workspace: { select: { title: true } },
+            },
+        });
+        const header = [
+            'createdAt',
+            'actorEmail',
+            'actorName',
+            'description',
+            'trpcPath',
+            'category',
+            'status',
+            'durationMs',
+            'workspaceTitle',
+            'errorCode',
+        ].join(',');
+        const lines = rows.map((r) => [
+            csvEscapeCell(r.createdAt.toISOString()),
+            csvEscapeCell(r.actor?.email),
+            csvEscapeCell(r.actor?.name),
+            csvEscapeCell(getActivityHumanDescription(r.trpcPath, r.action)),
+            csvEscapeCell(r.trpcPath),
+            csvEscapeCell(r.category),
+            csvEscapeCell(r.status),
+            csvEscapeCell(r.durationMs),
+            csvEscapeCell(r.workspace?.title),
+            csvEscapeCell(r.errorCode),
+        ].join(','));
+        return {
+            csv: [header, ...lines].join('\n'),
+            count: rows.length,
+        };
+    }
+    async activityPurgeRetention() {
+        const days = getActivityRetentionDays();
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - days);
+        const { deleted } = await deleteActivityLogsOlderThan(this.db, cutoff);
+        this.logger.info(`ActivityLog retention purge: deleted ${deleted} rows older than ${days} days (cutoff ${cutoff.toISOString()})`, 'ADMIN');
+        return { deleted, retentionDays: days, cutoff };
+    }
+}