@goscribe/server 1.6.0 → 1.7.0

package/dist/src/services/workspace/workspace.service.js

@@ -0,0 +1,401 @@
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { supabaseClient } from '../../lib/storage.js';
+import PusherService from '../../lib/pusher.js';
+import { ai } from '../../lib/ai/index.js';
+import { workspaceKbService } from './workspace-kb.service.js';
+import { getAccountSummary, invalidateUserBillingCache, } from '../billing/usage.service.js';
+import { getUserStorageLimit } from '../billing/subscription.service.js';
+import { notifyWorkspaceDeleted } from '../notifications/notification.service.js';
+export class WorkspaceService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async list(userId, parentId) {
+        const workspaces = await this.db.workspace.findMany({
+            where: { ownerId: userId, folderId: parentId },
+            orderBy: { updatedAt: 'desc' },
+        });
+        const folders = await this.db.folder.findMany({
+            where: { ownerId: userId, parentId },
+        });
+        return { workspaces, folders };
+    }
+    async getTree(userId) {
+        const [allFolders, allWorkspaces] = await Promise.all([
+            this.db.folder.findMany({
+                where: { ownerId: userId },
+                select: {
+                    id: true,
+                    name: true,
+                    parentId: true,
+                    color: true,
+                    markerColor: true,
+                    updatedAt: true,
+                },
+                orderBy: { updatedAt: 'desc' },
+            }),
+            this.db.workspace.findMany({
+                where: { ownerId: userId },
+                select: {
+                    id: true,
+                    title: true,
+                    folderId: true,
+                    icon: true,
+                    color: true,
+                    markerColor: true,
+                    updatedAt: true,
+                    uploads: {
+                        select: {
+                            id: true,
+                            name: true,
+                            mimeType: true,
+                            createdAt: true,
+                        },
+                    },
+                },
+                orderBy: { updatedAt: 'desc' },
+            }),
+        ]);
+        return { folders: allFolders, workspaces: allWorkspaces };
+    }
+    async create(userId, input) {
+        const ws = await this.db.workspace.create({
+            data: {
+                title: input.name,
+                description: input.description,
+                ownerId: userId,
+                folderId: input.parentId ?? null,
+                ...(input.markerColor !== undefined ? { markerColor: input.markerColor } : {}),
+            },
+        });
+        void ai.backend.initSession(ws.id, userId).catch((err) => {
+            this.logger.error('Failed to init AI session on workspace creation:', err);
+        });
+        void workspaceKbService.ensureWorkspaceKb(ws.id, userId, input.name).catch((err) => {
+            this.logger.error('Failed to create workspace knowledge base:', err);
+        });
+        invalidateUserBillingCache(userId);
+        void PusherService.emitLibraryUpdate(userId);
+        return ws;
+    }
+    async createFolder(userId, input) {
+        const folder = await this.db.folder.create({
+            data: {
+                name: input.name,
+                ownerId: userId,
+                color: input.color ?? '#9D00FF',
+                parentId: input.parentId ?? null,
+            },
+        });
+        await PusherService.emitLibraryUpdate(userId);
+        return folder;
+    }
+    async updateFolder(userId, input) {
+        const folder = await this.db.folder.update({
+            where: { id: input.id },
+            data: { name: input.name, markerColor: input.markerColor },
+        });
+        await PusherService.emitLibraryUpdate(userId);
+        return folder;
+    }
+    async deleteFolder(userId, id) {
+        const folder = await this.db.folder.delete({ where: { id } });
+        await PusherService.emitLibraryUpdate(userId);
+        return folder;
+    }
+    async get(userId, id) {
+        const ws = await this.db.workspace.findFirst({
+            where: { id, ownerId: userId },
+            select: {
+                id: true,
+                title: true,
+                description: true,
+                icon: true,
+                color: true,
+                markerColor: true,
+                ownerId: true,
+                folderId: true,
+                fileBeingAnalyzed: true,
+                analysisProgress: true,
+                needsAnalysis: true,
+                createdAt: true,
+                updatedAt: true,
+                folder: { select: { id: true, name: true, color: true } },
+                uploads: {
+                    select: {
+                        id: true,
+                        name: true,
+                        mimeType: true,
+                        size: true,
+                        createdAt: true,
+                        objectKey: true,
+                    },
+                    orderBy: { createdAt: 'desc' },
+                },
+            },
+        });
+        if (!ws)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ws;
+    }
+    async getAccountSummary(userId) {
+        return getAccountSummary(userId);
+    }
+    async getStats(userId) {
+        const summary = await getAccountSummary(userId);
+        return summary.stats;
+    }
+    async update(userId, input) {
+        const existed = await this.db.workspace.findFirst({
+            where: { id: input.id, ownerId: userId },
+        });
+        if (!existed)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const updated = await this.db.workspace.update({
+            where: { id: input.id },
+            data: {
+                title: input.name ?? existed.title,
+                description: input.description,
+                markerColor: input.markerColor !== undefined ? input.markerColor : existed.markerColor,
+                icon: input.icon ?? existed.icon,
+            },
+        });
+        await PusherService.emitLibraryUpdate(userId);
+        return updated;
+    }
+    async delete(userId, id) {
+        const workspaceToDelete = await this.db.workspace.findFirst({
+            where: { id, ownerId: userId },
+            select: {
+                id: true,
+                title: true,
+                ownerId: true,
+                members: { select: { userId: true } },
+            },
+        });
+        if (!workspaceToDelete)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const actor = await this.db.user.findUnique({
+            where: { id: userId },
+            select: { name: true, email: true },
+        });
+        const actorName = actor?.name || actor?.email || 'A user';
+        await notifyWorkspaceDeleted(this.db, {
+            recipientUserIds: workspaceToDelete.members.map((m) => m.userId),
+            actorUserId: userId,
+            actorName,
+            workspaceId: workspaceToDelete.id,
+            workspaceTitle: workspaceToDelete.title,
+        });
+        const deleted = await this.db.workspace.deleteMany({
+            where: { id, ownerId: userId },
+        });
+        if (deleted.count === 0)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        await PusherService.emitLibraryUpdate(userId);
+        return true;
+    }
+    async getFolderInformation(userId, id) {
+        const folder = await this.db.folder.findFirst({
+            where: { id, ownerId: userId },
+        });
+        if (!folder)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const parents = [];
+        let current = folder;
+        while (current.parentId) {
+            const parent = await this.db.folder.findFirst({
+                where: { id: current.parentId, ownerId: userId },
+            });
+            if (!parent)
+                break;
+            parents.push(parent);
+            current = parent;
+        }
+        return { folder, parents };
+    }
+    async getSharedWith(userId, id) {
+        const user = await this.db.user.findFirst({ where: { id: userId } });
+        if (!user || !user.email)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const sharedWith = await this.db.workspace.findMany({
+            where: { members: { some: { userId } } },
+        });
+        const invitations = await this.db.workspaceInvitation.findMany({
+            where: { email: user.email, acceptedAt: null },
+            include: { workspace: true },
+        });
+        return { shared: sharedWith, invitations };
+    }
+    async uploadFiles(userId, input) {
+        const ws = await this.db.workspace.findFirst({
+            where: { id: input.id, ownerId: userId },
+        });
+        if (!ws)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const workspaces = await this.db.workspace.findMany({
+            where: {
+                OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
+            },
+        });
+        const spaceUsed = await this.db.fileAsset.aggregate({
+            where: { workspaceId: { in: workspaces.map((w) => w.id) }, userId },
+            _sum: { size: true },
+        });
+        const storageLimit = await getUserStorageLimit(userId);
+        const totalSize = input.files.reduce((acc, file) => acc + file.size, 0);
+        if ((spaceUsed._sum?.size ?? 0) + totalSize > storageLimit) {
+            this.logger.warn(`Storage limit exceeded for user ${userId}. Used: ${spaceUsed._sum?.size}, Tried to upload: ${totalSize}, Limit: ${storageLimit}`);
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: `Storage limit exceeded. Maximum allowed storage is ${(storageLimit / (1024 * 1024 * 1024)).toFixed(1)}GB.`,
+            });
+        }
+        const results = [];
+        for (const file of input.files) {
+            const record = await this.db.fileAsset.create({
+                data: {
+                    userId,
+                    name: file.filename,
+                    mimeType: file.contentType,
+                    size: file.size,
+                    workspaceId: input.id,
+                },
+            });
+            const objectKey = `${userId}/${record.id}-${file.filename}`;
+            const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+                .from('media')
+                .createSignedUploadUrl(objectKey);
+            if (signedUrlError) {
+                throw new TRPCError({
+                    code: 'INTERNAL_SERVER_ERROR',
+                    message: `Failed to upload file`,
+                });
+            }
+            await this.db.fileAsset.update({
+                where: { id: record.id },
+                data: {
+                    bucket: 'media',
+                    objectKey,
+                },
+            });
+            results.push({
+                fileId: record.id,
+                uploadUrl: signedUrlData.signedUrl,
+            });
+        }
+        return results;
+    }
+    async deleteFiles(userId, input) {
+        const files = await this.db.fileAsset.findMany({
+            where: {
+                id: { in: input.fileId },
+                workspaceId: input.id,
+                userId,
+            },
+        });
+        for (const file of files) {
+            if (file.bucket && file.objectKey) {
+                supabaseClient.storage
+                    .from(file.bucket)
+                    .remove([file.objectKey])
+                    .catch((err) => {
+                    this.logger.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
+                });
+            }
+        }
+        await this.db.fileAsset.deleteMany({
+            where: {
+                id: { in: input.fileId },
+                workspaceId: input.id,
+                userId,
+            },
+        });
+        return true;
+    }
+    async getFileUploadUrl(userId, input) {
+        const workspaces = await this.db.workspace.findMany({
+            where: {
+                OR: [{ ownerId: userId }, { sharedWith: { some: { id: userId } } }],
+            },
+        });
+        const spaceUsed = await this.db.fileAsset.aggregate({
+            where: { workspaceId: { in: workspaces.map((w) => w.id) }, userId },
+            _sum: { size: true },
+        });
+        const storageLimit = await getUserStorageLimit(userId);
+        if ((spaceUsed._sum?.size ?? 0) + input.size > storageLimit) {
+            this.logger.warn(`Storage limit exceeded for user ${userId}. Used: ${spaceUsed._sum?.size}, Tried to upload: ${input.size}, Limit: ${storageLimit}`);
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: `Storage limit exceeded. Maximum allowed storage is ${(storageLimit / (1024 * 1024 * 1024)).toFixed(1)}GB.`,
+            });
+        }
+        const objectKey = `workspace_${userId}/${input.workspaceId}-file_${input.filename}`;
+        const fileAsset = await this.db.fileAsset.create({
+            data: {
+                workspaceId: input.workspaceId,
+                name: input.filename,
+                mimeType: input.contentType,
+                size: input.size,
+                userId,
+                bucket: 'media',
+                objectKey,
+            },
+        });
+        const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+            .from('media')
+            .createSignedUploadUrl(objectKey, { upsert: true });
+        if (signedUrlError) {
+            this.logger.error('Signed upload URL error:', signedUrlError);
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to create upload URL: ${signedUrlError.message}`,
+            });
+        }
+        await this.db.workspace.update({
+            where: { id: input.workspaceId },
+            data: { needsAnalysis: true },
+        });
+        return {
+            fileId: fileAsset.id,
+            uploadUrl: signedUrlData.signedUrl,
+        };
+    }
+    async search(userId, input) {
+        const { query, color } = input;
+        const workspaces = await this.db.workspace.findMany({
+            where: {
+                ownerId: userId,
+                markerColor: color || undefined,
+                ...(query
+                    ? {
+                        OR: [
+                            { title: { contains: query, mode: 'insensitive' } },
+                            { description: { contains: query, mode: 'insensitive' } },
+                        ],
+                    }
+                    : {}),
+            },
+            orderBy: { updatedAt: 'desc' },
+            take: input.limit,
+        });
+        const folders = await this.db.folder.findMany({
+            where: {
+                ownerId: userId,
+                markerColor: color || undefined,
+                ...(query ? { name: { contains: query, mode: 'insensitive' } } : {}),
+            },
+            orderBy: { updatedAt: 'desc' },
+            take: input.limit,
+        });
+        const results = [
+            ...workspaces.map((w) => ({ ...w, type: 'workspace' })),
+            ...folders.map((f) => ({ ...f, type: 'folder', title: f.name })),
+        ]
+            .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
+            .slice(0, input.limit);
+        return results;
+    }
+}

package/dist/src/trpc.d.ts

@@ -0,0 +1,60 @@
+import type { Context } from "./context.js";
+export declare const router: import("@trpc/server").TRPCRouterBuilder<{
+    ctx: 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;
+}>;
+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;
+    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>>;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
+    db: import("@prisma/client").PrismaClient;
+    cookies: import("cookie").Cookies;
+}, 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;
+    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>>;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
+    db: import("@prisma/client").PrismaClient;
+    cookies: import("cookie").Cookies;
+}, 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;
+    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>>;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
+    db: import("@prisma/client").PrismaClient;
+    cookies: import("cookie").Cookies;
+}, 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;
+    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>>;
+    session: {
+        user: import("./context.js").SessionUser;
+    };
+    db: import("@prisma/client").PrismaClient;
+    cookies: import("cookie").Cookies;
+}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;

package/dist/src/trpc.js

@@ -0,0 +1,217 @@
+import { initTRPC, TRPCError } from "@trpc/server";
+import superjson from "superjson";
+import { ActivityLogStatus } from "@prisma/client";
+import { logger } from "./lib/logger.js";
+import { toTRPCError } from "./lib/errors.js";
+import { getUserUsage, getUserPlanLimits } from "./services/billing/usage.service.js";
+import { getClientIp, isActivityLogEnabled, scheduleRecordActivity, truncateUserAgent, } from "./services/activity/activity-log.service.js";
+/** Avoid logging the log viewers themselves (noise when browsing activity). */
+const SKIP_ACTIVITY_TRPC_PATHS = new Set([
+    "admin.activityList",
+    "admin.activityExportCsv",
+]);
+const t = initTRPC.context().create({
+    transformer: superjson,
+    errorFormatter({ shape, error }) {
+        // Log errors in development
+        if (process.env.NODE_ENV === 'development') {
+            logger.error('TRPC Error', 'TRPC', {
+                code: error.code,
+                message: error.message,
+                cause: error.cause,
+            });
+        }
+        return {
+            ...shape,
+            data: {
+                ...shape.data,
+                zodError: error.cause instanceof Error ? error.cause.message : null,
+            },
+        };
+    },
+});
+export const router = t.router;
+export const middleware = t.middleware;
+export const publicProcedure = t.procedure;
+/**
+ * Logging middleware
+ */
+const loggingMiddleware = middleware(async ({ ctx, next, path, type }) => {
+    const start = Date.now();
+    const result = await next();
+    const duration = Date.now() - start;
+    logger.info(`TRPC ${type} ${path}`, 'TRPC', {
+        duration: `${duration}ms`,
+        userId: ctx.session?.user?.id,
+    });
+    return result;
+});
+/**
+ * Middleware that enforces authentication
+ */
+const isAuthed = middleware(({ ctx, next }) => {
+    const hasUser = Boolean(ctx.session?.user?.id);
+    if (!ctx.session || !hasUser) {
+        throw new TRPCError({
+            code: "UNAUTHORIZED",
+            message: "You must be logged in to access this resource"
+        });
+    }
+    return next({
+        ctx: {
+            ...ctx,
+            session: ctx.session,
+            userId: ctx.session.user.id,
+        },
+    });
+});
+/**
+ * Error handling middleware
+ */
+const errorHandler = middleware(async ({ next }) => {
+    try {
+        return await next();
+    }
+    catch (error) {
+        throw toTRPCError(error);
+    }
+});
+/**
+ * Middleware that enforces email verification
+ */
+const isVerified = middleware(({ ctx, next }) => {
+    const user = ctx.session?.user;
+    if (!user?.emailVerified) {
+        throw new TRPCError({
+            code: "FORBIDDEN",
+            message: "Please verify your email to access this feature",
+        });
+    }
+    return next();
+});
+/**
+ * Middleware that enforces resource limits based on the user's plan.
+ * Note: This matches the 'path' to decide which limit to check.
+ */
+const checkUsageLimit = middleware(async ({ ctx, next, path }) => {
+    const userId = ctx.session.user.id;
+    // 1. Get current usage and limits
+    const [usage, limits] = await Promise.all([
+        getUserUsage(userId),
+        getUserPlanLimits(userId)
+    ]);
+    // If no limits found (no active plan), we block any premium actions
+    if (!limits) {
+        throw new TRPCError({
+            code: "FORBIDDEN",
+            message: "No active plan found. Please subscribe to a plan to continue.",
+        });
+    }
+    // 2. Check limits based on the tRPC path
+    // Flashcards (matches: flashcards.createCard, flashcards.generateFromPrompt)
+    if (path.startsWith('flashcards.') && (path.includes('create') || path.includes('generate')) && usage.flashcards >= limits.maxFlashcards) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Flashcard limit reached for your plan." });
+    }
+    // Worksheets (matches: worksheets.create, worksheets.generateFromPrompt)
+    if (path.startsWith('worksheets.') && (path.includes('create') || path.includes('generate')) && usage.worksheets >= limits.maxWorksheets) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Worksheet limit reached for your plan." });
+    }
+    // Podcasts (matches: podcast.generateEpisode)
+    if (path.startsWith('podcast.') && path.includes('generate') && usage.podcasts >= limits.maxPodcasts) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Podcast limit reached for your plan." });
+    }
+    // Study Guides (matches: studyguide.get - because it lazily creates)
+    if (path.startsWith('studyguide.') && path.includes('get') && usage.studyGuides >= limits.maxStudyGuides) {
+        // Note: We only block if the artifact doesn't exist yet (handled inside the query or by checking usage)
+        // For simplicity, if they hit the limit, we block creation of NEW study guides.
+        // However, usage_service counts existing ones. 
+        // If usage is already at/over limit, it means any NEW workspace's 'get' will fail creation.
+    }
+    // Storage check (for uploads)
+    if (path.includes('upload') && usage.storageBytes >= Number(limits.maxStorageBytes)) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Storage limit reached for your plan." });
+    }
+    return next();
+});
+/**
+ * Middleware that enforces system admin role
+ */
+const isAdmin = middleware(({ ctx, next }) => {
+    const user = ctx.session?.user;
+    if (!user?.isSystemAdmin) {
+        throw new TRPCError({
+            code: "FORBIDDEN",
+            message: "You do not have permission to access this resource",
+        });
+    }
+    return next();
+});
+/**
+ * Persists ActivityLog rows for authenticated tRPC calls (async, non-blocking).
+ */
+const activityLogMiddleware = middleware(async (opts) => {
+    const { ctx, next, path, type, getRawInput } = opts;
+    if (!isActivityLogEnabled() || SKIP_ACTIVITY_TRPC_PATHS.has(path)) {
+        return next();
+    }
+    const userId = ctx.userId;
+    if (!userId) {
+        return next();
+    }
+    let rawInput;
+    try {
+        rawInput = await getRawInput();
+    }
+    catch {
+        rawInput = undefined;
+    }
+    const req = ctx.req;
+    const ipAddress = req ? getClientIp(req) : undefined;
+    const userAgent = req.headers["user-agent"];
+    const httpMethod = req.method;
+    const start = Date.now();
+    const result = await next();
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        scheduleRecordActivity({
+            db: ctx.db,
+            actorUserId: userId,
+            path,
+            type,
+            status: ActivityLogStatus.SUCCESS,
+            durationMs,
+            rawInput,
+            ipAddress,
+            userAgent: truncateUserAgent(typeof userAgent === "string" ? userAgent : undefined),
+            httpMethod,
+        });
+    }
+    else {
+        scheduleRecordActivity({
+            db: ctx.db,
+            actorUserId: userId,
+            path,
+            type,
+            status: ActivityLogStatus.FAILURE,
+            durationMs,
+            rawInput,
+            ipAddress,
+            userAgent: truncateUserAgent(typeof userAgent === "string" ? userAgent : undefined),
+            httpMethod,
+            errorCode: result.error.code,
+        });
+    }
+    return result;
+});
+/** Exported procedures with middleware */
+export const authedProcedure = publicProcedure
+    .use(loggingMiddleware)
+    .use(errorHandler)
+    .use(isAuthed)
+    .use(activityLogMiddleware);
+export const verifiedProcedure = authedProcedure
+    .use(isVerified);
+export const adminProcedure = authedProcedure
+    .use(isAdmin);
+export const limitedProcedure = verifiedProcedure
+    .use(checkUsageLimit);