@goscribe/server 1.3.4 → 1.6.0

package/src/scripts/purge-deleted-users.ts

@@ -2,12 +2,12 @@ import { PrismaClient } from '@prisma/client';
 import { supabaseClient } from '../lib/storage.js';
 import { logger } from '../lib/logger.js';
 import { env } from '../lib/env.js';
-import { notifyAdminsAccountPermanentlyDeleted } from '../lib/notification-service.js';
+import { notifyAdminsAccountPermanentlyDeleted } from '../services/notifications/notification.service.js';
 import {
   ActivityLogCategory,
   ActivityLogStatus,
 } from '@prisma/client';
-import { recordExplicitActivity } from '../lib/activity_log_service.js';
+import { recordExplicitActivity } from '../services/activity/activity-log.service.js';
 
 const db = new PrismaClient();
 

package/src/server.ts

@@ -15,7 +15,7 @@ import {
   ActivityLogCategory,
   ActivityLogStatus,
 } from '@prisma/client';
-import { recordExplicitActivity } from './lib/activity_log_service.js';
+import { recordExplicitActivity } from './services/activity/activity-log.service.js';
 
 const PORT = process.env.PORT ? Number(process.env.PORT) : 3001;
 
@@ -50,7 +50,7 @@ async function main() {
     const sig = req.headers['stripe-signature'];
     const { stripe } = await import('./lib/stripe.js');
     const { env } = await import('./lib/env.js');
-    const subscriptionService = await import('./lib/subscription_service.js');
+    const subscriptionService = await import('./services/billing/subscription.service.js');
 
     let event;
 
@@ -195,9 +195,16 @@ async function main() {
     }),
   );
 
-  app.listen(PORT, () => {
+  app.listen(PORT, async () => {
     logger.info(`Server ready on http://localhost:${PORT}`, 'SERVER');
     logger.info(`tRPC endpoint at http://localhost:${PORT}/trpc`, 'SERVER');
+
+    try {
+      const { ensureCuratedKbCatalog } = await import('./lib/ensure-curated-kb-catalog.js');
+      await ensureCuratedKbCatalog(prisma);
+    } catch (err) {
+      logger.error('Failed to seed curated knowledge bases', 'KB', undefined, err instanceof Error ? err : undefined);
+    }
   });
 }
 

package/src/{lib/activity_human_description.test.ts → services/activity/activity-human-description.service.test.ts}

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import {
   getActivityHumanDescription,
   getTrpcPathsMatchingDescriptionSearch,
-} from "./activity_human_description.js";
+} from "./activity-human-description.service.js";
 
 test("description search resolves paths by label substring", () => {
   const paths = getTrpcPathsMatchingDescriptionSearch("study streak");

package/src/{lib/activity_log_service.test.ts → services/activity/activity-log.service.test.ts}

@@ -5,7 +5,7 @@ import {
   buildActivityLogWhere,
   inferCategoryFromTrpcPath,
   redactSensitive,
-} from "./activity_log_service.js";
+} from "./activity-log.service.js";
 
 test("redactSensitive redacts sensitive keys", () => {
   const out = redactSensitive({

package/src/{lib/activity_log_service.ts → services/activity/activity-log.service.ts}

@@ -7,8 +7,8 @@
 import type { Prisma, PrismaClient } from "@prisma/client";
 import { ActivityLogCategory, ActivityLogStatus } from "@prisma/client";
 import type { IncomingMessage } from "node:http";
-import { logger } from "./logger.js";
-import { getTrpcPathsMatchingDescriptionSearch } from "./activity_human_description.js";
+import { logger } from "../../lib/logger.js";
+import { getTrpcPathsMatchingDescriptionSearch } from "./activity-human-description.service.js";
 
 const SENSITIVE_KEY_FRAGMENTS = [
   "password",

package/src/services/admin/admin.service.ts

@@ -0,0 +1,612 @@
+import type { PrismaClient } from '@prisma/client';
+import { ActivityLogCategory, ActivityLogStatus, ArtifactType, InvoiceType } from '@prisma/client';
+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: string | number | null | undefined): string {
+  if (value === null || value === undefined) return '';
+  const s = String(value);
+  if (/[",\n\r]/.test(s)) return `"${s.replace(/"/g, '""')}"`;
+  return s;
+}
+
+export interface ActivityFilters {
+  from?: Date;
+  to?: Date;
+  actorUserId?: string;
+  workspaceId?: string;
+  category?: ActivityLogCategory;
+  status?: ActivityLogStatus;
+  search?: string;
+}
+
+export interface ListUsersInput {
+  page: number;
+  pageSize: number;
+  search?: string;
+  emailVerified: 'all' | 'yes' | 'no';
+  joinedFrom?: Date;
+  joinedTo?: Date;
+}
+
+export interface ListInvoicesInput {
+  page: number;
+  pageSize: number;
+  search?: string;
+  status?: string;
+  type?: InvoiceType;
+  userId?: string;
+  from?: Date;
+  to?: Date;
+}
+
+export interface UpsertPlanInput {
+  id?: string;
+  name: string;
+  description?: string;
+  type: string;
+  price: number;
+  stripePriceId?: string;
+  interval: string | null;
+  active: boolean;
+  limits: {
+    maxStorageBytes: number;
+    maxWorksheets: number;
+    maxFlashcards: number;
+    maxPodcasts: number;
+    maxStudyGuides: number;
+  };
+}
+
+export class AdminService extends BaseService {
+  constructor(db: PrismaClient) {
+    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 as any).invoice.aggregate({
+      where: { status: 'paid', type: 'SUBSCRIPTION' },
+      _sum: { amountPaid: true },
+    });
+    const topupRevenueResult = await (this.db as any).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: ListUsersInput) {
+    const search = input.search?.trim();
+    const baseRoleWhere = {
+      role: { name: { not: 'System Admin' } },
+    } as const;
+
+    const searchWhere =
+      search && search.length > 0
+        ? {
+            OR: [
+              { email: { contains: search, mode: 'insensitive' as const } },
+              { name: { contains: search, mode: 'insensitive' as const } },
+              { 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: any) => ({
+        ...user,
+        profilePicture: user.profilePicture?.objectKey
+          ? `/profile-picture/${user.profilePicture.objectKey}?t=${new Date(user.updatedAt).getTime()}`
+          : null,
+      })),
+      page,
+      pageSize,
+      totalCount,
+      totalPages,
+    };
+  }
+
+  async listInvoices(input: ListInvoicesInput) {
+    const search = input.search?.trim();
+
+    const searchWhere =
+      search && search.length > 0
+        ? {
+            OR: [
+              { id: { contains: search } },
+              { stripeInvoiceId: { contains: search, mode: 'insensitive' as const } },
+              { user: { email: { contains: search, mode: 'insensitive' as const } } },
+              { user: { name: { contains: search, mode: 'insensitive' as const } } },
+            ],
+          }
+        : 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 as any).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 as any).invoice.findMany({
+      where,
+      skip,
+      take: pageSize,
+      orderBy: { createdAt: 'desc' },
+      include: {
+        user: { include: { profilePicture: true } },
+        subscription: { include: { plan: true } },
+      },
+    });
+
+    const items = invoices.map((invoice: any) => ({
+      ...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: { limit: number; cursor?: string | null }) {
+    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: typeof input.cursor | undefined = undefined;
+    if (workspaces.length > input.limit) {
+      const nextItem = workspaces.pop();
+      nextCursor = nextItem!.id;
+    }
+
+    return { workspaces, nextCursor };
+  }
+
+  async updateUserRole(actorId: string, input: { userId: string; roleName: string }) {
+    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: string, input: UpsertPlanInput) {
+    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 as any) || '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: any) {
+        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: string, id: string) {
+    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: { userId: string; limit?: number }) {
+    return (this.db as any).invoice.findMany({
+      where: { userId: input.userId },
+      orderBy: { createdAt: 'desc' },
+      take: input.limit,
+      include: {
+        subscription: { include: { plan: true } },
+      },
+    });
+  }
+
+  async getUserDetailedInfo(userId: string) {
+    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 as any).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 as any).profilePicture?.objectKey
+      ? `/profile-picture/${(user as any).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 as any).invoice.count();
+    const all = await (this.db as any).invoice.findMany({ take: 10 });
+    return { count, all };
+  }
+
+  listResourcePrices() {
+    return this.db.resourcePrice.findMany({
+      orderBy: { resourceType: 'asc' },
+    });
+  }
+
+  async upsertResourcePrice(
+    actorId: string,
+    input: { resourceType: ArtifactType; priceCents: number },
+  ) {
+    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: number) {
+    const invoices = await (this.db as any).invoice.findMany({
+      take: limit,
+      orderBy: { createdAt: 'desc' },
+      include: {
+        user: { include: { profilePicture: true } },
+      },
+    });
+
+    return invoices.map((invoice: any) => ({
+      ...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: ActivityFilters & { page: number; limit: number }) {
+    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: ActivityFilters & { maxRows: number }) {
+    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 };
+  }
+}

package/src/services/ai/ai-session.service.ts

@@ -0,0 +1,5 @@
+/**
+ * Back-compat shim — prefer `import { ai } from '../../lib/ai/index.js'`.
+ */
+export { inferenceBackend as aiSessionService } from '../../lib/ai/inference-backend/client.js';
+export type { AISession, ProcessFileResult } from '../../lib/ai/inference-backend/types.js';