@goscribe/server 1.2.0 → 1.3.1

package/dist/scripts/purge-deleted-users.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/purge-deleted-users.js

@@ -0,0 +1,149 @@
+import { PrismaClient } from '@prisma/client';
+import { supabaseClient } from '../lib/storage.js';
+import { logger } from '../lib/logger.js';
+import { notifyAdminsAccountPermanentlyDeleted } from '../lib/notification-service.js';
+import { ActivityLogCategory, ActivityLogStatus, } from '@prisma/client';
+import { recordExplicitActivity } from '../lib/activity_log_service.js';
+const db = new PrismaClient();
+async function purgeDeletedUsers() {
+    try {
+        const startedAt = Date.now();
+        let status = ActivityLogStatus.SUCCESS;
+        let errorCode = null;
+        let purgedUsers = 0;
+        logger.info('Starting scheduled purge for deleted users...');
+        // Find users whose deletedAt is older than 30 days
+        const thirtyDaysAgo = new Date();
+        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+        const usersToPurge = await db.user.findMany({
+            where: {
+                deletedAt: {
+                    lte: thirtyDaysAgo,
+                },
+            },
+            select: {
+                id: true,
+                name: true,
+                email: true,
+                profilePicture: {
+                    select: {
+                        objectKey: true,
+                    }
+                }
+            },
+        });
+        if (usersToPurge.length === 0) {
+            logger.info('No users found past the 30-day grace period.');
+            await recordExplicitActivity({
+                db,
+                actorUserId: null,
+                action: 'cron.purgeDeletedUsers',
+                category: ActivityLogCategory.SYSTEM,
+                status: ActivityLogStatus.SUCCESS,
+                errorCode: null,
+                durationMs: Date.now() - startedAt,
+                forceWrite: true,
+                metadata: {
+                    usersFound: 0,
+                    usersPurged: 0,
+                    graceDays: 30,
+                },
+            });
+            return;
+        }
+        logger.info(`Found ${usersToPurge.length} user(s) to purge. Processing...`);
+        for (const user of usersToPurge) {
+            logger.info(`Purging user: ${user.id} (${user.email})`);
+            try {
+                // 1. Delete associated files from Supabase Storage
+                //    (Prisma cascade will delete the FileAsset DB record, but we need to delete the actual file first)
+                // Let's get all file assets owned by the user
+                const userFiles = await db.fileAsset.findMany({
+                    where: { userId: user.id },
+                    select: { objectKey: true, bucket: true },
+                });
+                for (const file of userFiles) {
+                    if (file.objectKey && file.bucket) {
+                        try {
+                            const { error } = await supabaseClient.storage
+                                .from(file.bucket)
+                                .remove([file.objectKey]);
+                            if (error) {
+                                logger.error(`Failed to delete file from Supabase: ${file.objectKey}`, error);
+                            }
+                            else {
+                                logger.info(`Deleted file from Supabase: ${file.objectKey}`);
+                            }
+                        }
+                        catch (storageError) {
+                            logger.error(`Exception during Supabase deletion for ${file.objectKey}:`, storageError);
+                        }
+                    }
+                }
+                await notifyAdminsAccountPermanentlyDeleted(db, {
+                    id: user.id,
+                    name: user.name,
+                    email: user.email,
+                }).catch(() => { });
+                // 2. Finally, delete the User from the database
+                //    (Prisma onDelete: Cascade will handle almost everything else depending on schema)
+                await db.user.delete({
+                    where: { id: user.id },
+                });
+                purgedUsers += 1;
+                logger.info(`Successfully purged user: ${user.id}`);
+            }
+            catch (userError) {
+                status = ActivityLogStatus.FAILURE;
+                errorCode =
+                    userError instanceof Error ? userError.message : String(userError);
+                logger.error(`Failed to purge user ${user.id}:`, userError);
+            }
+        }
+        if (status === ActivityLogStatus.SUCCESS) {
+            logger.info('Purge process completed successfully.');
+        }
+        else {
+            logger.warn('Purge process completed with failures.');
+        }
+        await recordExplicitActivity({
+            db,
+            actorUserId: null,
+            action: 'cron.purgeDeletedUsers',
+            category: ActivityLogCategory.SYSTEM,
+            status,
+            errorCode,
+            durationMs: Date.now() - startedAt,
+            forceWrite: true,
+            metadata: {
+                usersFound: usersToPurge.length,
+                usersPurged: purgedUsers,
+                graceDays: 30,
+            },
+        });
+    }
+    catch (error) {
+        const startedAt = Date.now();
+        await recordExplicitActivity({
+            db,
+            actorUserId: null,
+            action: 'cron.purgeDeletedUsers',
+            category: ActivityLogCategory.SYSTEM,
+            status: ActivityLogStatus.FAILURE,
+            errorCode: error instanceof Error ? error.message : String(error),
+            durationMs: Date.now() - startedAt,
+            forceWrite: true,
+        }).catch(() => { });
+        logger.error('Critical error during user purge process:', error);
+    }
+    finally {
+        await db.$disconnect();
+    }
+}
+// Run the script
+purgeDeletedUsers().then(() => {
+    process.exit(0);
+}).catch((error) => {
+    console.error("Unhandled error:", error);
+    process.exit(1);
+});

package/dist/server.js

@@ -7,20 +7,24 @@ import compression from 'compression';
 import * as trpcExpress from '@trpc/server/adapters/express';
 import { appRouter } from './routers/_app.js';
 import { createContext } from './context.js';
+import { prisma } from './lib/prisma.js';
 import { logger } from './lib/logger.js';
 import { supabaseClient } from './lib/storage.js';
+import { ActivityLogCategory, ActivityLogStatus, } from '@prisma/client';
+import { recordExplicitActivity } from './lib/activity_log_service.js';
 const PORT = process.env.PORT ? Number(process.env.PORT) : 3001;
 async function main() {
     const app = express();
     // Middlewares
-    app.use(helmet());
     app.use(cors({
-        origin: process.env.FRONTEND_URL || "http://localhost:3000",
+        origin: ['https://www.scribe.study', 'https://scribe.study', 'http://localhost:3000', 'http://localhost:3002'],
         credentials: true, // allow cookies
         methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
         allowedHeaders: ['Content-Type', 'Authorization', 'Cookie', 'Set-Cookie'],
         exposedHeaders: ['Set-Cookie'],
+        preflightContinue: false, // Important: stop further handling of OPTIONS
     }));
+    app.use(helmet());
     // Custom morgan middleware with logger integration
     app.use(morgan('combined', {
         stream: {
@@ -30,6 +34,112 @@ async function main() {
         }
     }));
     app.use(compression());
+    // Stripe Webhook (Must be before express.json() for raw body)
+    app.post('/stripe/webhook', express.raw({ type: 'application/json' }), async (req, res) => {
+        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');
+        let event;
+        try {
+            if (!sig || !env.STRIPE_WEBHOOK_SECRET) {
+                throw new Error('Missing stripe-signature or STRIPE_WEBHOOK_SECRET');
+            }
+            event = stripe?.webhooks.constructEvent(req.body, sig, env.STRIPE_WEBHOOK_SECRET);
+        }
+        catch (err) {
+            logger.error(`Webhook signature verification failed: ${err.message}`, 'STRIPE');
+            await recordExplicitActivity({
+                db: prisma,
+                actorUserId: null,
+                action: 'stripe.webhook.signatureVerificationFailed',
+                category: ActivityLogCategory.SYSTEM,
+                status: ActivityLogStatus.FAILURE,
+                errorCode: err?.message ?? 'unknown',
+                durationMs: 0,
+                forceWrite: true,
+            }).catch(() => { });
+            return res.status(400).send(`Webhook Error: ${err.message}`);
+        }
+        // Handle the event
+        try {
+            const startedAt = Date.now();
+            let status = ActivityLogStatus.SUCCESS;
+            let errorCode = null;
+            // Best-effort: some webhook objects include metadata.userId
+            let actorUserId = undefined;
+            try {
+                const obj = event?.data?.object;
+                const md = obj?.metadata;
+                if (md && typeof md.userId === 'string')
+                    actorUserId = md.userId;
+            }
+            catch {
+                actorUserId = undefined;
+            }
+            switch (event?.type) {
+                case 'checkout.session.completed':
+                    await subscriptionService.handleCheckoutCompleted(event);
+                    break;
+                case 'customer.subscription.created':
+                    await subscriptionService.handleSubscriptionCreated(event);
+                    break;
+                case 'customer.subscription.updated':
+                    await subscriptionService.handleSubscriptionUpdated(event);
+                    break;
+                case 'customer.subscription.deleted':
+                    await subscriptionService.handleSubscriptionDeleted(event);
+                    break;
+                case 'invoice.paid':
+                case 'invoice.payment_succeeded':
+                    await subscriptionService.handleInvoicePaid(event);
+                    break;
+                case 'invoice.payment_failed':
+                    await subscriptionService.handlePaymentFailed(event);
+                    break;
+                case 'payment_intent.payment_failed':
+                    await subscriptionService.handlePaymentIntentFailed(event);
+                    break;
+                default:
+                    logger.debug(`Unhandled stripe event type: ${event?.type}`, 'STRIPE');
+            }
+            await recordExplicitActivity({
+                db: prisma,
+                actorUserId: actorUserId ?? undefined,
+                action: `stripe.webhook.${event?.type}`,
+                category: ActivityLogCategory.SYSTEM,
+                status,
+                errorCode,
+                durationMs: Date.now() - startedAt,
+                forceWrite: true,
+                metadata: {
+                    stripeEventId: event?.id,
+                    stripeEventType: event?.type,
+                },
+            }).catch(() => { });
+            res.json({ received: true });
+        }
+        catch (err) {
+            const startedAt = Date.now();
+            const message = err?.message ?? 'unknown';
+            await recordExplicitActivity({
+                db: prisma,
+                actorUserId: null,
+                action: `stripe.webhook.${event?.type}`,
+                category: ActivityLogCategory.SYSTEM,
+                status: ActivityLogStatus.FAILURE,
+                errorCode: message,
+                durationMs: Date.now() - startedAt,
+                forceWrite: true,
+                metadata: {
+                    stripeEventId: event?.id,
+                    stripeEventType: event?.type,
+                },
+            }).catch(() => { });
+            logger.error(`Error processing webhook event ${event?.type}: ${err.message}`, 'STRIPE');
+            res.status(500).send('Internal Server Error');
+        }
+    });
     app.use(express.json({ limit: '50mb' }));
     app.use(express.urlencoded({ limit: '50mb', extended: true }));
     // Health (plain Express)
@@ -37,15 +147,25 @@ async function main() {
         res.json({ ok: true, service: 'trpc-express', ts: Date.now() });
     });
     app.get('/profile-picture/:objectKey', async (req, res) => {
-        const { objectKey } = req.params;
-        const signedUrl = await supabaseClient.storage
-            .from('media')
-            .createSignedUrl(objectKey, 60 * 60 * 24 * 30);
-        if (signedUrl.error) {
-            return res.status(500).json({ error: 'Failed to generate signed URL' });
+        try {
+            const { objectKey } = req.params;
+            const { data, error } = await supabaseClient.storage
+                .from('media')
+                .download(objectKey);
+            if (error || !data) {
+                logger.error(`Failed to download profile picture: ${error?.message}`, 'STORAGE');
+                return res.status(404).send('Not found');
+            }
+            const buffer = Buffer.from(await data.arrayBuffer());
+            res.setHeader('Content-Type', 'image/jpeg');
+            res.setHeader('Cache-Control', 'public, max-age=31536000');
+            res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+            res.send(buffer);
+        }
+        catch (err) {
+            logger.error('Error serving profile picture', 'STORAGE', undefined, err);
+            res.status(500).send('Internal Server Error');
         }
-        // res.json({ url: signedUrl.data.signedUrl });
-        res.redirect(signedUrl.data.signedUrl);
     });
     // tRPC mounted under /trpc
     app.use('/trpc', trpcExpress.createExpressMiddleware({

package/dist/services/flashcard-progress.service.d.ts

@@ -1,4 +1,4 @@
-import type { PrismaClient } from '@prisma/client';
+import { Prisma, type PrismaClient } from '@prisma/client';
 /**
  * SM-2 Spaced Repetition Algorithm
  * https://www.supermemo.com/en/archives1990-2015/english/ol/sm2
@@ -39,33 +39,7 @@ export declare class FlashcardProgressService {
         isCorrect: boolean;
         confidence?: 'easy' | 'medium' | 'hard';
         timeSpentMs?: number;
-    }): Promise<{
-        flashcard: {
-            id: string;
-            createdAt: Date;
-            artifactId: string;
-            order: number;
-            front: string;
-            back: string;
-            tags: string[];
-        };
-    } & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        userId: string;
-        flashcardId: string;
-        timesStudied: number;
-        timesCorrect: number;
-        timesIncorrect: number;
-        timesIncorrectConsecutive: number;
-        easeFactor: number;
-        interval: number;
-        repetitions: number;
-        masteryLevel: number;
-        lastStudiedAt: Date | null;
-        nextReviewAt: Date | null;
-    }>;
+    }, retryCount?: number): Promise<any>;
     /**
      * Get user's progress on all flashcards in a set
      */
@@ -99,17 +73,18 @@ export declare class FlashcardProgressService {
             id: string;
             createdAt: Date;
             updatedAt: Date;
-            title: string;
-            description: string | null;
             workspaceId: string;
             type: import("@prisma/client").$Enums.ArtifactType;
+            title: string;
             isArchived: boolean;
-            generating: boolean;
-            generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
             difficulty: import("@prisma/client").$Enums.Difficulty | null;
             estimatedTime: string | null;
-            imageObjectKey: string | null;
             createdById: string | null;
+            description: string | null;
+            generating: boolean;
+            generatingMetadata: Prisma.JsonValue | null;
+            worksheetConfig: Prisma.JsonValue | null;
+            imageObjectKey: string | null;
         };
     } & {
         id: string;
@@ -119,22 +94,24 @@ export declare class FlashcardProgressService {
         front: string;
         back: string;
         tags: string[];
+        acceptedAnswers: string[];
     }) | {
         artifact: {
             id: string;
             createdAt: Date;
             updatedAt: Date;
-            title: string;
-            description: string | null;
             workspaceId: string;
             type: import("@prisma/client").$Enums.ArtifactType;
+            title: string;
             isArchived: boolean;
-            generating: boolean;
-            generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
             difficulty: import("@prisma/client").$Enums.Difficulty | null;
             estimatedTime: string | null;
-            imageObjectKey: string | null;
             createdById: string | null;
+            description: string | null;
+            generating: boolean;
+            generatingMetadata: Prisma.JsonValue | null;
+            worksheetConfig: Prisma.JsonValue | null;
+            imageObjectKey: string | null;
         };
         id: string;
         createdAt: Date;
@@ -143,6 +120,7 @@ export declare class FlashcardProgressService {
         front: string;
         back: string;
         tags: string[];
+        acceptedAnswers: string[];
     })[]>;
     /**
      * Get user statistics for a flashcard set
@@ -161,7 +139,7 @@ export declare class FlashcardProgressService {
     /**
      * Reset progress for a flashcard
      */
-    resetProgress(userId: string, flashcardId: string): Promise<import("@prisma/client").Prisma.BatchPayload>;
+    resetProgress(userId: string, flashcardId: string): Promise<Prisma.BatchPayload>;
     /**
      * Bulk record study session
      */
@@ -173,33 +151,7 @@ export declare class FlashcardProgressService {
             confidence?: 'easy' | 'medium' | 'hard';
             timeSpentMs?: number;
         }>;
-    }): Promise<({
-        flashcard: {
-            id: string;
-            createdAt: Date;
-            artifactId: string;
-            order: number;
-            front: string;
-            back: string;
-            tags: string[];
-        };
-    } & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        userId: string;
-        flashcardId: string;
-        timesStudied: number;
-        timesCorrect: number;
-        timesIncorrect: number;
-        timesIncorrectConsecutive: number;
-        easeFactor: number;
-        interval: number;
-        repetitions: number;
-        masteryLevel: number;
-        lastStudiedAt: Date | null;
-        nextReviewAt: Date | null;
-    })[]>;
+    }): Promise<any[]>;
 }
 /**
  * Factory function

package/dist/services/flashcard-progress.service.js

@@ -1,3 +1,4 @@
+import { Prisma } from '@prisma/client';
 import { NotFoundError } from '../lib/errors.js';
 export class FlashcardProgressService {
     constructor(db) {
@@ -105,7 +106,7 @@ export class FlashcardProgressService {
     /**
      * Record flashcard study attempt
      */
-    async recordStudyAttempt(data) {
+    async recordStudyAttempt(data, retryCount = 0) {
         const { userId, flashcardId, isCorrect, timeSpentMs } = data;
         // Verify flashcard exists and user has access
         const flashcard = await this.db.flashcard.findFirst({
@@ -155,44 +156,55 @@ export class FlashcardProgressService {
             (Math.min(sm2Result.repetitions, 10) / 10) * 30 - // 30% weight on repetitions
             consecutivePenalty // Penalty for consecutive failures
         )));
-        // Upsert progress
-        return this.db.flashcardProgress.upsert({
-            where: {
-                userId_flashcardId: {
+        try {
+            // Upsert progress
+            return await this.db.flashcardProgress.upsert({
+                where: {
+                    userId_flashcardId: {
+                        userId,
+                        flashcardId,
+                    },
+                },
+                update: {
+                    timesStudied: { increment: 1 },
+                    timesCorrect: isCorrect ? { increment: 1 } : undefined,
+                    timesIncorrect: !isCorrect ? { increment: 1 } : undefined,
+                    timesIncorrectConsecutive: newConsecutiveIncorrect,
+                    easeFactor: sm2Result.easeFactor,
+                    interval: sm2Result.interval,
+                    repetitions: sm2Result.repetitions,
+                    masteryLevel,
+                    lastStudiedAt: new Date(),
+                    nextReviewAt: sm2Result.nextReviewAt,
+                },
+                create: {
                     userId,
                     flashcardId,
+                    timesStudied: 1,
+                    timesCorrect: isCorrect ? 1 : 0,
+                    timesIncorrect: isCorrect ? 0 : 1,
+                    timesIncorrectConsecutive: newConsecutiveIncorrect,
+                    easeFactor: sm2Result.easeFactor,
+                    interval: sm2Result.interval,
+                    repetitions: sm2Result.repetitions,
+                    masteryLevel,
+                    lastStudiedAt: new Date(),
+                    nextReviewAt: sm2Result.nextReviewAt,
                 },
-            },
-            update: {
-                timesStudied: { increment: 1 },
-                timesCorrect: isCorrect ? { increment: 1 } : undefined,
-                timesIncorrect: !isCorrect ? { increment: 1 } : undefined,
-                timesIncorrectConsecutive: newConsecutiveIncorrect,
-                easeFactor: sm2Result.easeFactor,
-                interval: sm2Result.interval,
-                repetitions: sm2Result.repetitions,
-                masteryLevel,
-                lastStudiedAt: new Date(),
-                nextReviewAt: sm2Result.nextReviewAt,
-            },
-            create: {
-                userId,
-                flashcardId,
-                timesStudied: 1,
-                timesCorrect: isCorrect ? 1 : 0,
-                timesIncorrect: isCorrect ? 0 : 1,
-                timesIncorrectConsecutive: newConsecutiveIncorrect,
-                easeFactor: sm2Result.easeFactor,
-                interval: sm2Result.interval,
-                repetitions: sm2Result.repetitions,
-                masteryLevel,
-                lastStudiedAt: new Date(),
-                nextReviewAt: sm2Result.nextReviewAt,
-            },
-            include: {
-                flashcard: true,
-            },
-        });
+                include: {
+                    flashcard: true,
+                },
+            });
+        }
+        catch (error) {
+            // Handle rare race condition where parallel submissions try creating same row.
+            if (error instanceof Prisma.PrismaClientKnownRequestError &&
+                error.code === 'P2002' &&
+                retryCount < 1) {
+                return this.recordStudyAttempt(data, retryCount + 1);
+            }
+            throw error;
+        }
     }
     /**
      * Get user's progress on all flashcards in a set
@@ -253,7 +265,7 @@ export class FlashcardProgressService {
                 },
             },
         });
-        console.log('allFlashcards', allFlashcards.length);
+        // allFlashcards count logged for debugging if needed
         const TAKE_NUMBER = (allFlashcards.length > 10) ? 10 : allFlashcards.length;
         // Get progress records for flashcards that are due or have low mastery
         const progressRecords = await this.db.flashcardProgress.findMany({
@@ -289,9 +301,7 @@ export class FlashcardProgressService {
             },
             take: TAKE_NUMBER,
         });
-        console.log('TAKE_NUMBER', TAKE_NUMBER);
-        console.log('TAKE_NUMBER - progressRecords.length', TAKE_NUMBER - progressRecords.length);
-        console.log('progressRecords', progressRecords.map((progress) => progress.flashcard.id));
+        // Due card selection: TAKE_NUMBER=${TAKE_NUMBER}, existing=${progressRecords.length}
         // Get flashcard IDs that already have progress records
         const flashcardIdsWithProgress = new Set(progressRecords.map((progress) => progress.flashcard.id));
         // Find flashcards without progress records (non-studied) to pad the results
@@ -318,8 +328,7 @@ export class FlashcardProgressService {
                 flashcard: flashcardWithoutProgress,
             };
         });
-        console.log('progressRecordsPadding', progressRecordsPadding.length);
-        console.log('progressRecords', progressRecords.length);
+        // Combined: ${progressRecords.length} due + ${progressRecordsPadding.length} padding cards
         const selectedCards = [...progressRecords, ...progressRecordsPadding];
         // Build result array: include progress records and non-studied flashcards
         const results = [];

package/dist/trpc.d.ts

@@ -1,11 +1,6 @@
+import type { Context } from "./context.js";
 export declare const router: import("@trpc/server").TRPCRouterBuilder<{
-    ctx: {
-        db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
-        session: any;
-        req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
-        res: import("express").Response<any, Record<string, any>>;
-        cookies: Record<string, string | undefined>;
-    };
+    ctx: Context;
     meta: object;
     errorShape: {
         data: {
@@ -20,34 +15,38 @@ export declare const router: import("@trpc/server").TRPCRouterBuilder<{
     };
     transformer: true;
 }>;
-export declare const middleware: <$ContextOverrides>(fn: import("@trpc/server").TRPCMiddlewareFunction<{
-    db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
+export declare const middleware: <$ContextOverrides>(fn: import("@trpc/server").TRPCMiddlewareFunction<Context, object, object, $ContextOverrides, unknown>) => import("@trpc/server").TRPCMiddlewareBuilder<Context, object, $ContextOverrides, unknown>;
+export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+/** Exported procedures with middleware */
+export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
+    userId: any;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: Record<string, string | undefined>;
-}, object, object, $ContextOverrides, unknown>) => import("@trpc/server").TRPCMiddlewareBuilder<{
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
+    cookies: Record<string, string | undefined>;
+}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+export declare const verifiedProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
+    userId: any;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: Record<string, string | undefined>;
-}, object, $ContextOverrides, unknown>;
-export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<{
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
+    cookies: Record<string, string | undefined>;
+}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+export declare const adminProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
+    userId: any;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: Record<string, string | undefined>;
-}, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
-/** Exported procedures with middleware */
-export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilder<{
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
+    cookies: Record<string, string | undefined>;
+}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+export declare const limitedProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, {
+    userId: any;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
+    db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     cookies: Record<string, string | undefined>;
-}, object, {
-    session: any;
-    userId: any;
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;