@goscribe/server 1.5.0 → 1.7.0

package/dist/src/routers/members.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { router, publicProcedure, authedProcedure } from '../trpc.js';
+import { MemberService } from '../services/members/member.service.js';
+import { InvitationService } from '../services/members/invitation.service.js';
+export const members = router({
+    getMembers: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(({ ctx, input }) => new MemberService(ctx.db).getMembers(ctx.session.user.id, input.workspaceId)),
+    getCurrentUserRole: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(({ ctx, input }) => new MemberService(ctx.db).getCurrentUserRole(ctx.session.user.id, input.workspaceId)),
+    inviteMember: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        email: z.string().email(),
+        role: z.enum(['admin', 'member']).default('member'),
+    }))
+        .mutation(({ ctx, input }) => new InvitationService(ctx.db).inviteMember(ctx.session.user.id, input)),
+    getInvitations: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(({ ctx, input }) => new InvitationService(ctx.db).getInvitations(input.workspaceId)),
+    acceptInvite: publicProcedure
+        .input(z.object({ token: z.string() }))
+        .mutation(({ ctx, input }) => new InvitationService(ctx.db).acceptInvite(ctx.session?.user?.id, input.token)),
+    changeMemberRole: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        memberId: z.string(),
+        role: z.enum(['admin', 'member']),
+    }))
+        .mutation(({ ctx, input }) => new MemberService(ctx.db).changeMemberRole(ctx.session.user.id, input)),
+    removeMember: authedProcedure
+        .input(z.object({ workspaceId: z.string(), memberId: z.string() }))
+        .mutation(({ ctx, input }) => new MemberService(ctx.db).removeMember(ctx.session.user.id, input)),
+    getPendingInvitations: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(({ ctx, input }) => new InvitationService(ctx.db).getPendingInvitations(ctx.session.user.id, input.workspaceId)),
+    cancelInvitation: authedProcedure
+        .input(z.object({ invitationId: z.string() }))
+        .mutation(({ ctx, input }) => new InvitationService(ctx.db).cancelInvitation(ctx.session.user.id, input.invitationId)),
+    resendInvitation: authedProcedure
+        .input(z.object({ invitationId: z.string() }))
+        .mutation(({ ctx, input }) => new InvitationService(ctx.db).resendInvitation(ctx.session.user.id, input.invitationId)),
+    getAllInvitationsDebug: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(({ ctx, input }) => new InvitationService(ctx.db).getAllInvitationsDebug(ctx.session.user.id, input.workspaceId)),
+});

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

@@ -0,0 +1,99 @@
+export declare const notifications: 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<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            cursor?: string | undefined;
+            limit?: number | undefined;
+            unreadOnly?: boolean | undefined;
+            types?: string[] | undefined;
+        };
+        output: {
+            items: ({
+                workspace: {
+                    id: string;
+                    title: string;
+                } | null;
+                actor: {
+                    id: string;
+                    email: string | null;
+                    name: string | null;
+                } | null;
+            } & {
+                userId: string;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                title: string;
+                type: string;
+                workspaceId: string | null;
+                metadata: import("@prisma/client/runtime/client").JsonValue | null;
+                actorUserId: string | null;
+                body: string;
+                actionUrl: string | null;
+                priority: import("../../generated/prisma/enums.js").NotificationPriority;
+                sourceId: string | null;
+                content: string | null;
+                read: boolean;
+                readAt: Date | null;
+                deliveredAt: Date | null;
+            })[];
+            nextCursor: string | undefined;
+        };
+        meta: object;
+    }>;
+    unreadCount: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            count: number;
+        };
+        meta: object;
+    }>;
+    markRead: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    markManyRead: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            ids: string[];
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    markAllRead: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+}>>;

package/dist/src/routers/notifications.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { authedProcedure, router } from '../trpc.js';
+import { NotificationService } from '../services/notifications/notification.service.js';
+const listInputSchema = z.object({
+    cursor: z.string().optional(),
+    limit: z.number().min(1).max(50).default(20),
+    unreadOnly: z.boolean().optional(),
+    types: z.array(z.string()).optional(),
+});
+export const notifications = router({
+    list: authedProcedure
+        .input(listInputSchema)
+        .query(({ ctx, input }) => new NotificationService(ctx.db).list(ctx.userId, input)),
+    unreadCount: authedProcedure.query(({ ctx }) => new NotificationService(ctx.db).unreadCount(ctx.userId)),
+    markRead: authedProcedure
+        .input(z.object({ id: z.string() }))
+        .mutation(({ ctx, input }) => new NotificationService(ctx.db).markRead(ctx.userId, input.id)),
+    markManyRead: authedProcedure
+        .input(z.object({ ids: z.array(z.string()).min(1) }))
+        .mutation(({ ctx, input }) => new NotificationService(ctx.db).markManyRead(ctx.userId, input.ids)),
+    markAllRead: authedProcedure.mutation(({ ctx }) => new NotificationService(ctx.db).markAllRead(ctx.userId)),
+    delete: authedProcedure
+        .input(z.object({ id: z.string() }))
+        .mutation(({ ctx, input }) => new NotificationService(ctx.db).delete(ctx.userId, input.id)),
+});

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

@@ -0,0 +1,80 @@
+import { ArtifactType } from '@prisma/client';
+export declare const paymentRouter: 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<{
+    getPlans: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: any[];
+        meta: object;
+    }>;
+    createCheckoutSession: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            planId: string;
+        };
+        output: {
+            url: string | null;
+        };
+        meta: object;
+    }>;
+    confirmCheckoutSuccess: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            sessionId: string;
+        };
+        output: {
+            confirmed: boolean;
+            reason: string;
+            kind?: undefined;
+        } | {
+            confirmed: boolean;
+            kind: "payment";
+            reason?: undefined;
+        } | {
+            confirmed: boolean;
+            kind: "subscription";
+            reason?: undefined;
+        };
+        meta: object;
+    }>;
+    createResourcePurchaseSession: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            resourceType: "WORKSHEET" | "STORAGE" | "STUDY_GUIDE" | "FLASHCARD_SET" | "MEETING_SUMMARY" | "PODCAST_EPISODE";
+            quantity?: number | undefined;
+        };
+        output: {
+            url: string | null;
+        };
+        meta: object;
+    }>;
+    getUsageOverview: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            usage: import("../services/billing/usage.service.js").UserUsage;
+            limits: import("../services/billing/usage.service.js").UserPlanLimits;
+            hasActivePlan: boolean;
+        };
+        meta: object;
+    }>;
+    getResourcePrices: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            updatedAt: Date;
+            resourceType: ArtifactType;
+            priceCents: number;
+        }[];
+        meta: object;
+    }>;
+}>>;

package/dist/src/routers/payment.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { router, publicProcedure, verifiedProcedure } from '../trpc.js';
+import { ArtifactType } from '@prisma/client';
+import { PaymentService } from '../services/billing/payment.service.js';
+export const paymentRouter = router({
+    getPlans: publicProcedure.query(({ ctx }) => new PaymentService(ctx.db).getPlans(ctx.session?.user?.id)),
+    createCheckoutSession: verifiedProcedure
+        .input(z.object({ planId: z.string() }))
+        .mutation(({ ctx, input }) => new PaymentService(ctx.db).createCheckoutSession(ctx.userId, input)),
+    confirmCheckoutSuccess: verifiedProcedure
+        .input(z.object({ sessionId: z.string().min(1) }))
+        .mutation(({ ctx, input }) => new PaymentService(ctx.db).confirmCheckoutSuccess(ctx.userId, input)),
+    createResourcePurchaseSession: verifiedProcedure
+        .input(z.object({
+        resourceType: z.nativeEnum(ArtifactType),
+        quantity: z.number().min(1).default(1),
+    }))
+        .mutation(({ ctx, input }) => new PaymentService(ctx.db).createResourcePurchaseSession(ctx.userId, input)),
+    getUsageOverview: verifiedProcedure.query(({ ctx }) => new PaymentService(ctx.db).getUsageOverview(ctx.userId)),
+    getResourcePrices: verifiedProcedure.query(({ ctx }) => new PaymentService(ctx.db).getResourcePrices()),
+});

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

@@ -0,0 +1,287 @@
+export declare const podcast: 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<{
+    listEpisodes: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: {
+            id: string;
+            title: string;
+            description: string | null;
+            metadata: {
+                title: string;
+                totalDuration: number;
+                speakers: {
+                    id: string;
+                    role: "host" | "guest" | "expert";
+                    name?: string | undefined;
+                }[];
+                summary: {
+                    executiveSummary: string;
+                    learningObjectives: string[];
+                    keyConcepts: string[];
+                    followUpActions: string[];
+                    targetAudience: string;
+                    prerequisites: string[];
+                    tags: string[];
+                };
+                generatedAt: string;
+                description?: string | undefined;
+            } | null;
+            imageUrl: string | null;
+            segments: ({
+                id: string;
+                title: string;
+                audioUrl: string;
+                objectKey: string;
+                startTime: number;
+                duration: number;
+                order: number;
+            } | {
+                id: string;
+                title: string;
+                audioUrl: null;
+                objectKey: string | null;
+                startTime: number;
+                duration: number;
+                order: number;
+            })[];
+            createdAt: Date;
+            updatedAt: Date;
+            workspaceId: string;
+            generating: boolean;
+            generatingMetadata: import("@prisma/client/runtime/client").JsonValue;
+            type: import("../lib/prisma.js").ArtifactType;
+            createdById: string | null;
+            isArchived: boolean;
+        }[];
+        meta: object;
+    }>;
+    getEpisode: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            episodeId: string;
+        };
+        output: {
+            id: string;
+            title: string;
+            description: string | undefined;
+            metadata: {
+                title: string;
+                totalDuration: number;
+                speakers: {
+                    id: string;
+                    role: "host" | "guest" | "expert";
+                    name?: string | undefined;
+                }[];
+                summary: {
+                    executiveSummary: string;
+                    learningObjectives: string[];
+                    keyConcepts: string[];
+                    followUpActions: string[];
+                    targetAudience: string;
+                    prerequisites: string[];
+                    tags: string[];
+                };
+                generatedAt: string;
+                description?: string | undefined;
+            };
+            imageUrl: string | null;
+            segments: ({
+                id: string;
+                title: string;
+                content: string;
+                audioUrl: string;
+                objectKey: string;
+                startTime: number;
+                duration: number;
+                keyPoints: string[];
+                order: number;
+            } | {
+                id: string;
+                title: string;
+                content: string;
+                audioUrl: null;
+                objectKey: string | null;
+                startTime: number;
+                duration: number;
+                keyPoints: string[];
+                order: number;
+            })[];
+            content: string;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+        meta: object;
+    }>;
+    generateEpisode: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            podcastData: {
+                title: string;
+                userPrompt: string;
+                description?: string | undefined;
+                speakers?: {
+                    id: string;
+                    role: "host" | "guest" | "expert";
+                    name?: string | undefined;
+                }[] | undefined;
+                speed?: number | undefined;
+                generateIntro?: boolean | undefined;
+                generateOutro?: boolean | undefined;
+                segmentByTopics?: boolean | undefined;
+            };
+        };
+        output: {
+            id: string;
+            title: any;
+            description: string | undefined;
+            metadata: {
+                title: any;
+                description: string | undefined;
+                totalDuration: number;
+                summary: any;
+                speakers: {
+                    id: string;
+                    role: "host" | "guest" | "expert";
+                    name?: string | undefined;
+                }[];
+                generatedAt: string;
+            };
+            content: string;
+        };
+        meta: object;
+    }>;
+    deleteSegment: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            segmentId: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            title: string;
+            duration: number;
+            objectKey: string | null;
+            artifactId: string;
+            content: string;
+            meta: import("@prisma/client/runtime/client").JsonValue | null;
+            order: number;
+            generating: boolean;
+            generatingMetadata: import("@prisma/client/runtime/client").JsonValue | null;
+            startTime: number;
+            audioUrl: string | null;
+            keyPoints: string[];
+        };
+        meta: object;
+    }>;
+    getEpisodeSchema: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            episodeId: string;
+        };
+        output: {
+            segments: {
+                id: string;
+                title: string;
+                startTime: number;
+                duration: number;
+                keyPoints: string[];
+                order: number;
+            }[];
+            summary: {
+                executiveSummary: string;
+                learningObjectives: string[];
+                keyConcepts: string[];
+                followUpActions: string[];
+                targetAudience: string;
+                prerequisites: string[];
+                tags: string[];
+            };
+            metadata: {
+                title: string;
+                description: string | undefined;
+                totalDuration: number;
+                speakers: {
+                    id: string;
+                    role: "host" | "guest" | "expert";
+                    name?: string | undefined;
+                }[];
+            };
+        };
+        meta: object;
+    }>;
+    updateEpisode: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            episodeId: string;
+            title?: string | undefined;
+            description?: string | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            title: string;
+            description: string | null;
+            createdById: string | null;
+            type: import("../lib/prisma.js").ArtifactType;
+            workspaceId: string;
+            difficulty: import("../../generated/prisma/enums.js").Difficulty | null;
+            estimatedTime: string | null;
+            isArchived: boolean;
+            generating: boolean;
+            generatingMetadata: import("@prisma/client/runtime/client").JsonValue | null;
+            worksheetConfig: import("@prisma/client/runtime/client").JsonValue | null;
+            imageObjectKey: string | null;
+        };
+        meta: object;
+    }>;
+    deleteEpisode: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            episodeId: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+    getSegment: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            segmentId: string;
+        };
+        output: {
+            id: string;
+            title: string;
+            content: string;
+            startTime: number;
+            duration: number;
+            order: number;
+            keyPoints: string[];
+            audioUrl: string | null;
+            objectKey: string | null;
+            meta: import("@prisma/client/runtime/client").JsonValue;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+        meta: object;
+    }>;
+    getAvailableVoices: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            name: string;
+            description: string;
+        }[];
+        meta: object;
+    }>;
+}>>;

package/dist/src/routers/podcast.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { router, authedProcedure, limitedProcedure } from '../trpc.js';
+import { PodcastService, podcastInputSchema } from '../services/content/podcast.service.js';
+export const podcast = router({
+    listEpisodes: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(({ ctx, input }) => new PodcastService(ctx.db).listEpisodes(ctx.session.user.id, input.workspaceId)),
+    getEpisode: authedProcedure
+        .input(z.object({ episodeId: z.string() }))
+        .query(({ ctx, input }) => new PodcastService(ctx.db).getEpisode(ctx.session.user.id, input.episodeId)),
+    generateEpisode: limitedProcedure
+        .input(z.object({ workspaceId: z.string(), podcastData: podcastInputSchema }))
+        .mutation(({ ctx, input }) => new PodcastService(ctx.db).generateEpisode(ctx.session.user.id, input)),
+    deleteSegment: authedProcedure
+        .input(z.object({ segmentId: z.string() }))
+        .mutation(({ ctx, input }) => new PodcastService(ctx.db).deleteSegment(input.segmentId)),
+    getEpisodeSchema: authedProcedure
+        .input(z.object({ episodeId: z.string() }))
+        .query(({ ctx, input }) => new PodcastService(ctx.db).getEpisodeSchema(ctx.session.user.id, input.episodeId)),
+    updateEpisode: authedProcedure
+        .input(z.object({
+        episodeId: z.string(),
+        title: z.string().optional(),
+        description: z.string().optional(),
+    }))
+        .mutation(({ ctx, input }) => new PodcastService(ctx.db).updateEpisode(ctx.session.user.id, input)),
+    deleteEpisode: authedProcedure
+        .input(z.object({ episodeId: z.string() }))
+        .mutation(({ ctx, input }) => new PodcastService(ctx.db).deleteEpisode(ctx.session.user.id, input.episodeId)),
+    getSegment: authedProcedure
+        .input(z.object({ segmentId: z.string() }))
+        .query(({ ctx, input }) => new PodcastService(ctx.db).getSegment(ctx.session.user.id, input.segmentId)),
+    getAvailableVoices: authedProcedure.query(({ ctx }) => new PodcastService(ctx.db).getAvailableVoices()),
+});

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

@@ -0,0 +1,36 @@
+export declare const studyguide: 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<{
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: {
+            artifactId: string;
+            title: string;
+            latestVersion: {
+                id: string;
+                createdAt: Date;
+                data: import("@prisma/client/runtime/client").JsonValue | null;
+                createdById: string | null;
+                artifactId: string;
+                content: string;
+                version: number;
+            };
+        };
+        meta: object;
+    }>;
+}>>;

package/dist/src/routers/studyguide.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { router, authedProcedure } from '../trpc.js';
+import { StudyGuideService } from '../services/artifacts/study-guide.service.js';
+export const studyguide = router({
+    get: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(({ ctx, input }) => new StudyGuideService(ctx.db).get(ctx.session.user.id, input.workspaceId)),
+});