@goscribe/server 1.5.0 → 1.7.0

package/dist/src/routers/_app.js

@@ -0,0 +1,36 @@
+import { router } from '../trpc.js';
+import { auth } from './auth.js';
+import { workspace } from './workspace.js';
+import { flashcards } from './flashcards.js';
+import { worksheets } from './worksheets.js';
+import { studyguide } from './studyguide.js';
+import { podcast } from './podcast.js';
+import { chat } from './chat.js';
+import { members } from './members.js';
+import { annotations } from './annotations.js';
+import { admin } from './admin.js';
+import { paymentRouter } from './payment.js';
+import { copilot } from './copilot.js';
+import { notifications } from './notifications.js';
+import { knowledgeBase } from './knowledgeBase.js';
+import { artifactVersions } from './artifactVersions.js';
+export const appRouter = router({
+    auth,
+    workspace,
+    flashcards,
+    worksheets,
+    studyguide,
+    podcast,
+    chat,
+    annotations,
+    admin,
+    payment: paymentRouter,
+    copilot,
+    notifications,
+    knowledgeBase,
+    artifactVersions,
+    // Public member endpoints (for invitation acceptance)
+    member: router({
+        acceptInvite: members.acceptInvite,
+    }),
+});

package/dist/src/routers/admin.d.ts

@@ -0,0 +1,358 @@
+import { ActivityLogCategory, ActivityLogStatus, ArtifactType } from '@prisma/client';
+export declare const admin: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../context.js").Context;
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: string | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getSystemStats: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            totalUsers: number;
+            totalWorkspaces: number;
+            totalSubscriptions: number;
+            revenue: number;
+            subscriptionRevenue: number;
+            topupRevenue: number;
+        };
+        meta: object;
+    }>;
+    listUsers: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            page?: number | undefined;
+            pageSize?: number | undefined;
+            search?: string | undefined;
+            emailVerified?: "all" | "yes" | "no" | undefined;
+            joinedFrom?: unknown;
+            joinedTo?: unknown;
+        };
+        output: {
+            users: any[];
+            page: number;
+            pageSize: number;
+            totalCount: number;
+            totalPages: number;
+        };
+        meta: object;
+    }>;
+    listInvoices: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            page?: number | undefined;
+            pageSize?: number | undefined;
+            search?: string | undefined;
+            status?: string | undefined;
+            type?: "TOPUP" | "SUBSCRIPTION" | undefined;
+            userId?: string | undefined;
+            from?: unknown;
+            to?: unknown;
+        };
+        output: {
+            items: any;
+            page: number;
+            pageSize: number;
+            totalCount: any;
+            totalPages: number;
+        };
+        meta: object;
+    }>;
+    listWorkspaces: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            limit?: number | undefined;
+            cursor?: string | null | undefined;
+        };
+        output: {
+            workspaces: ({
+                owner: {
+                    email: string | null;
+                    name: string | null;
+                };
+            } & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                title: string;
+                description: string | null;
+                icon: string;
+                color: string;
+                markerColor: string | null;
+                folderId: string | null;
+                fileBeingAnalyzed: boolean;
+                analysisProgress: import("@prisma/client/runtime/client").JsonValue | null;
+                needsAnalysis: boolean;
+            })[];
+            nextCursor: string | undefined;
+        };
+        meta: object;
+    }>;
+    updateUserRole: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            userId: string;
+            roleName: string;
+        };
+        output: {
+            id: string;
+            email: string | null;
+            stripe_customer_id: string | null;
+            name: string | null;
+            emailVerified: Date | null;
+            passwordHash: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+            fileAssetId: string | null;
+            roleId: string | null;
+            deletedAt: Date | null;
+        };
+        meta: object;
+    }>;
+    listPlans: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: ({
+            limit: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                planId: string;
+                maxStorageBytes: bigint;
+                maxWorksheets: number;
+                maxFlashcards: number;
+                maxPodcasts: number;
+                maxStudyGuides: number;
+            } | null;
+        } & {
+            id: string;
+            name: string;
+            createdAt: Date;
+            description: string | null;
+            type: string;
+            active: boolean;
+            price: number;
+            stripePriceId: string;
+            interval: string | null;
+        })[];
+        meta: object;
+    }>;
+    upsertPlan: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+            type: string;
+            price: number;
+            interval: string | null;
+            limits: {
+                maxStorageBytes: number;
+                maxWorksheets: number;
+                maxFlashcards: number;
+                maxPodcasts?: number | undefined;
+                maxStudyGuides?: number | undefined;
+            };
+            id?: string | undefined;
+            description?: string | undefined;
+            stripePriceId?: string | undefined;
+            active?: boolean | undefined;
+        };
+        output: {
+            id: string;
+            name: string;
+            createdAt: Date;
+            description: string | null;
+            type: string;
+            active: boolean;
+            price: number;
+            stripePriceId: string;
+            interval: string | null;
+        };
+        meta: object;
+    }>;
+    deletePlan: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
+    getUserInvoices: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            userId: string;
+            limit?: number | undefined;
+        };
+        output: any;
+        meta: object;
+    }>;
+    getUserDetailedInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            userId: string;
+        };
+        output: {
+            totalSpent: number;
+            purchasedCredits: {
+                type: ArtifactType;
+                amount: number;
+            }[];
+            profilePicture: string | null;
+            role: {
+                id: string;
+                name: string;
+            } | null;
+            subscriptions: ({
+                plan: {
+                    id: string;
+                    name: string;
+                    createdAt: Date;
+                    description: string | null;
+                    type: string;
+                    active: boolean;
+                    price: number;
+                    stripePriceId: string;
+                    interval: string | null;
+                };
+            } & {
+                userId: string;
+                id: string;
+                createdAt: Date;
+                planId: string;
+                stripeSubscriptionId: string;
+                stripeCustomerId: string | null;
+                status: string;
+                currentPeriodStart: Date;
+                currentPeriodEnd: Date;
+                cancelAt: Date | null;
+                canceledAt: Date | null;
+            })[];
+            _count: {
+                artifacts: number;
+                workspaces: number;
+            };
+            id: string;
+            email: string | null;
+            stripe_customer_id: string | null;
+            name: string | null;
+            emailVerified: Date | null;
+            passwordHash: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+            fileAssetId: string | null;
+            roleId: string | null;
+            deletedAt: Date | null;
+        };
+        meta: object;
+    }>;
+    debugInvoices: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            count: any;
+            all: any;
+        };
+        meta: object;
+    }>;
+    listResourcePrices: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            updatedAt: Date;
+            resourceType: ArtifactType;
+            priceCents: number;
+        }[];
+        meta: object;
+    }>;
+    upsertResourcePrice: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            resourceType: "WORKSHEET" | "STORAGE" | "STUDY_GUIDE" | "FLASHCARD_SET" | "MEETING_SUMMARY" | "PODCAST_EPISODE";
+            priceCents: number;
+        };
+        output: {
+            id: string;
+            updatedAt: Date;
+            resourceType: ArtifactType;
+            priceCents: number;
+        };
+        meta: object;
+    }>;
+    listRecentInvoices: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            limit?: number | undefined;
+        };
+        output: any;
+        meta: object;
+    }>;
+    activityList: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            from?: unknown;
+            to?: unknown;
+            actorUserId?: string | undefined;
+            workspaceId?: string | undefined;
+            category?: "AUTH" | "WORKSPACE" | "BILLING" | "ADMIN" | "CONTENT" | "SYSTEM" | undefined;
+            status?: "SUCCESS" | "FAILURE" | undefined;
+            search?: string | undefined;
+            page?: number | undefined;
+            limit?: number | undefined;
+        };
+        output: {
+            items: {
+                id: string;
+                createdAt: Date;
+                action: string;
+                description: string;
+                category: ActivityLogCategory;
+                trpcPath: string | null;
+                status: ActivityLogStatus;
+                durationMs: number;
+                errorCode: string | null;
+                ipAddress: string | null;
+                actor: {
+                    id: string;
+                    email: string | null;
+                    name: string | null;
+                } | null;
+                workspace: {
+                    id: string;
+                    title: string;
+                } | null;
+                metadata: import("@prisma/client/runtime/client").JsonValue;
+            }[];
+            page: number;
+            pageSize: number;
+            totalCount: number;
+            totalPages: number;
+        };
+        meta: object;
+    }>;
+    activityExportCsv: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            from?: unknown;
+            to?: unknown;
+            actorUserId?: string | undefined;
+            workspaceId?: string | undefined;
+            category?: "AUTH" | "WORKSPACE" | "BILLING" | "ADMIN" | "CONTENT" | "SYSTEM" | undefined;
+            status?: "SUCCESS" | "FAILURE" | undefined;
+            search?: string | undefined;
+            maxRows?: number | undefined;
+        };
+        output: {
+            csv: string;
+            count: number;
+        };
+        meta: object;
+    }>;
+    activityPurgeRetention: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            deleted: number;
+            retentionDays: number;
+            cutoff: Date;
+        };
+        meta: object;
+    }>;
+}>>;

package/dist/src/routers/admin.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { router, adminProcedure } from '../trpc.js';
+import { ActivityLogCategory, ActivityLogStatus, ArtifactType, InvoiceType } from '@prisma/client';
+import { AdminService } from '../services/admin/admin.service.js';
+const activityLogFiltersInput = z.object({
+    from: z.coerce.date().optional(),
+    to: z.coerce.date().optional(),
+    actorUserId: z.string().optional(),
+    workspaceId: z.string().optional(),
+    category: z.nativeEnum(ActivityLogCategory).optional(),
+    status: z.nativeEnum(ActivityLogStatus).optional(),
+    search: z.string().max(200).optional(),
+});
+const activityListInput = activityLogFiltersInput.extend({
+    page: z.number().int().min(1).default(1),
+    limit: z.number().min(1).max(100).default(20),
+});
+const listUsersInput = z.object({
+    page: z.number().int().min(1).default(1),
+    pageSize: z.number().int().min(1).max(100).default(10),
+    search: z.string().max(200).optional(),
+    emailVerified: z.enum(['all', 'yes', 'no']).default('all'),
+    joinedFrom: z.coerce.date().optional(),
+    joinedTo: z.coerce.date().optional(),
+});
+const listInvoicesInput = z.object({
+    page: z.number().int().min(1).default(1),
+    pageSize: z.number().int().min(1).max(100).default(10),
+    search: z.string().max(200).optional(),
+    status: z.string().max(32).optional(),
+    type: z.nativeEnum(InvoiceType).optional(),
+    userId: z.string().optional(),
+    from: z.coerce.date().optional(),
+    to: z.coerce.date().optional(),
+});
+export const admin = router({
+    getSystemStats: adminProcedure.query(({ ctx }) => new AdminService(ctx.db).getSystemStats()),
+    listUsers: adminProcedure
+        .input(listUsersInput)
+        .query(({ ctx, input }) => new AdminService(ctx.db).listUsers(input)),
+    listInvoices: adminProcedure
+        .input(listInvoicesInput)
+        .query(({ ctx, input }) => new AdminService(ctx.db).listInvoices(input)),
+    listWorkspaces: adminProcedure
+        .input(z.object({
+        limit: z.number().min(1).max(100).default(50),
+        cursor: z.string().nullish(),
+    }))
+        .query(({ ctx, input }) => new AdminService(ctx.db).listWorkspaces(input)),
+    updateUserRole: adminProcedure
+        .input(z.object({ userId: z.string(), roleName: z.string() }))
+        .mutation(({ ctx, input }) => new AdminService(ctx.db).updateUserRole(ctx.userId, input)),
+    listPlans: adminProcedure.query(({ ctx }) => new AdminService(ctx.db).listPlans()),
+    upsertPlan: adminProcedure
+        .input(z.object({
+        id: z.string().optional(),
+        name: z.string(),
+        description: z.string().optional(),
+        type: z.string(),
+        price: z.number(),
+        stripePriceId: z.string().optional(),
+        interval: z.string().nullable(),
+        active: z.boolean().default(true),
+        limits: z.object({
+            maxStorageBytes: z.number(),
+            maxWorksheets: z.number(),
+            maxFlashcards: z.number(),
+            maxPodcasts: z.number().default(0),
+            maxStudyGuides: z.number().default(0),
+        }),
+    }))
+        .mutation(({ ctx, input }) => new AdminService(ctx.db).upsertPlan(ctx.userId, input)),
+    deletePlan: adminProcedure
+        .input(z.object({ id: z.string() }))
+        .mutation(({ ctx, input }) => new AdminService(ctx.db).deletePlan(ctx.userId, input.id)),
+    getUserInvoices: adminProcedure
+        .input(z.object({
+        userId: z.string(),
+        limit: z.number().int().min(1).max(500).optional(),
+    }))
+        .query(({ ctx, input }) => new AdminService(ctx.db).getUserInvoices(input)),
+    getUserDetailedInfo: adminProcedure
+        .input(z.object({ userId: z.string() }))
+        .query(({ ctx, input }) => new AdminService(ctx.db).getUserDetailedInfo(input.userId)),
+    debugInvoices: adminProcedure.query(({ ctx }) => new AdminService(ctx.db).debugInvoices()),
+    listResourcePrices: adminProcedure.query(({ ctx }) => new AdminService(ctx.db).listResourcePrices()),
+    upsertResourcePrice: adminProcedure
+        .input(z.object({
+        resourceType: z.nativeEnum(ArtifactType),
+        priceCents: z.number().min(0),
+    }))
+        .mutation(({ ctx, input }) => new AdminService(ctx.db).upsertResourcePrice(ctx.userId, input)),
+    listRecentInvoices: adminProcedure
+        .input(z.object({ limit: z.number().default(10) }))
+        .query(({ ctx, input }) => new AdminService(ctx.db).listRecentInvoices(input.limit)),
+    activityList: adminProcedure
+        .input(activityListInput)
+        .query(({ ctx, input }) => new AdminService(ctx.db).activityList(input)),
+    activityExportCsv: adminProcedure
+        .input(activityLogFiltersInput.extend({
+        maxRows: z.number().min(1).max(5000).default(2000),
+    }))
+        .query(({ ctx, input }) => new AdminService(ctx.db).activityExportCsv(input)),
+    activityPurgeRetention: adminProcedure.mutation(({ ctx }) => new AdminService(ctx.db).activityPurgeRetention()),
+});