@goscribe/server 1.3.3 → 1.5.0

package/dist/routers/notes.d.ts

@@ -0,0 +1,94 @@
+export declare const notes: 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: {
+            workspaceId: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            title: string;
+            emoji: string;
+            blocks: import("@prisma/client/runtime/library").JsonValue;
+        }[];
+        meta: object;
+    }>;
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            noteId: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            workspaceId: string;
+            title: string;
+            userId: string;
+            emoji: string;
+            blocks: import("@prisma/client/runtime/library").JsonValue;
+        };
+        meta: object;
+    }>;
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            title?: string | undefined;
+            emoji?: string | undefined;
+            blocks?: unknown[] | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            workspaceId: string;
+            title: string;
+            userId: string;
+            emoji: string;
+            blocks: import("@prisma/client/runtime/library").JsonValue;
+        };
+        meta: object;
+    }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            noteId: string;
+            title?: string | undefined;
+            emoji?: string | undefined;
+            blocks?: unknown[] | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            workspaceId: string;
+            title: string;
+            userId: string;
+            emoji: string;
+            blocks: import("@prisma/client/runtime/library").JsonValue;
+        };
+        meta: object;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            noteId: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+}>>;

package/dist/routers/notes.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { router, authedProcedure } from '../trpc.js';
+import { NoteService } from '../services/note.service.js';
+const noteBlockSchema = z.lazy(() => z.object({
+    id: z.string().optional(),
+    type: z.string(),
+    props: z.record(z.string(), z.unknown()).optional(),
+    content: z.unknown().optional(),
+    children: z.array(noteBlockSchema).optional(),
+}));
+export const notes = router({
+    list: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(({ ctx, input }) => new NoteService(ctx.db).list(input.workspaceId, ctx.userId)),
+    get: authedProcedure
+        .input(z.object({ noteId: z.string() }))
+        .query(({ ctx, input }) => new NoteService(ctx.db).get(input.noteId, ctx.userId)),
+    create: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        title: z.string().optional(),
+        emoji: z.string().optional(),
+        blocks: z.array(noteBlockSchema).optional(),
+    }))
+        .mutation(({ ctx, input }) => new NoteService(ctx.db).create(input.workspaceId, ctx.userId, input)),
+    update: authedProcedure
+        .input(z.object({
+        noteId: z.string(),
+        title: z.string().optional(),
+        emoji: z.string().optional(),
+        blocks: z.array(noteBlockSchema).optional(),
+    }))
+        .mutation(({ ctx, input }) => new NoteService(ctx.db).update(input.noteId, ctx.userId, input)),
+    delete: authedProcedure
+        .input(z.object({ noteId: z.string() }))
+        .mutation(({ ctx, input }) => new NoteService(ctx.db).delete(input.noteId, ctx.userId)),
+});

package/dist/routers/notifications.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { authedProcedure, router } from '../trpc.js';
-import PusherService from '../lib/pusher.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),
@@ -10,118 +10,16 @@ const listInputSchema = z.object({
 export const notifications = router({
     list: authedProcedure
         .input(listInputSchema)
-        .query(async ({ ctx, input }) => {
-        const { cursor, limit, unreadOnly, types } = input;
-        const userId = ctx.userId;
-        const items = await ctx.db.notification.findMany({
-            where: {
-                userId,
-                ...(unreadOnly ? { read: false } : {}),
-                ...(types?.length ? { type: { in: types } } : {}),
-            },
-            include: {
-                actor: {
-                    select: {
-                        id: true,
-                        name: true,
-                        email: true,
-                    },
-                },
-                workspace: {
-                    select: {
-                        id: true,
-                        title: true,
-                    },
-                },
-            },
-            orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
-            take: limit + 1,
-            ...(cursor ? { cursor: { id: cursor }, skip: 1 } : {}),
-        });
-        let nextCursor;
-        if (items.length > limit) {
-            const next = items.pop();
-            nextCursor = next?.id;
-        }
-        return {
-            items,
-            nextCursor,
-        };
-    }),
-    unreadCount: authedProcedure.query(async ({ ctx }) => {
-        const count = await ctx.db.notification.count({
-            where: {
-                userId: ctx.userId,
-                read: false,
-            },
-        });
-        return { count };
-    }),
+        .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(async ({ ctx, input }) => {
-        const now = new Date();
-        await ctx.db.notification.updateMany({
-            where: {
-                id: input.id,
-                userId: ctx.userId,
-            },
-            data: {
-                read: true,
-                readAt: now,
-            },
-        });
-        const unreadCount = await ctx.db.notification.count({
-            where: { userId: ctx.userId, read: false },
-        });
-        await PusherService.emitNotificationReadState(ctx.userId, { unreadCount });
-        return { success: true };
-    }),
+        .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(async ({ ctx, input }) => {
-        const now = new Date();
-        await ctx.db.notification.updateMany({
-            where: {
-                id: { in: input.ids },
-                userId: ctx.userId,
-            },
-            data: {
-                read: true,
-                readAt: now,
-            },
-        });
-        const unreadCount = await ctx.db.notification.count({
-            where: { userId: ctx.userId, read: false },
-        });
-        await PusherService.emitNotificationReadState(ctx.userId, { unreadCount });
-        return { success: true };
-    }),
-    markAllRead: authedProcedure
-        .mutation(async ({ ctx }) => {
-        const now = new Date();
-        await ctx.db.notification.updateMany({
-            where: {
-                userId: ctx.userId,
-                read: false,
-            },
-            data: {
-                read: true,
-                readAt: now,
-            },
-        });
-        await PusherService.emitNotificationReadState(ctx.userId, { unreadCount: 0 });
-        return { success: true };
-    }),
+        .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(async ({ ctx, input }) => {
-        await ctx.db.notification.deleteMany({
-            where: {
-                id: input.id,
-                userId: ctx.userId,
-            },
-        });
-        return { success: true };
-    }),
+        .mutation(({ ctx, input }) => new NotificationService(ctx.db).delete(ctx.userId, input.id)),
 });

package/dist/routers/payment.d.ts

@@ -60,7 +60,7 @@ export declare const paymentRouter: import("@trpc/server").TRPCBuiltRouter<{
     getUsageOverview: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
         output: {
-            usage: import("../lib/usage_service.js").UserUsage;
+            usage: import("../services/billing/usage.service.js").UserUsage;
             limits: {
                 id: string;
                 planId: string;
@@ -71,7 +71,8 @@ export declare const paymentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 maxStudyGuides: number;
                 createdAt: Date;
                 updatedAt: Date;
-            } | null;
+                isFallbackPlan: boolean;
+            };
             hasActivePlan: boolean;
         };
         meta: object;