@goscribe/server 1.5.0 → 1.7.0

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

@@ -0,0 +1,219 @@
+export declare const annotations: 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<{
+    listHighlights: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            artifactVersionId: string;
+        };
+        output: ({
+            comments: ({
+                user: {
+                    id: string;
+                    name: string | null;
+                    profilePicture: {
+                        userId: string | null;
+                        id: string;
+                        name: string;
+                        createdAt: Date;
+                        size: number;
+                        workspaceId: string | null;
+                        url: string | null;
+                        objectKey: string | null;
+                        mimeType: string;
+                        bucket: string | null;
+                        checksum: string | null;
+                        meta: import("@prisma/client/runtime/client").JsonValue | null;
+                        aiTranscription: import("@prisma/client/runtime/client").JsonValue | null;
+                    } | null;
+                };
+            } & {
+                userId: string;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                highlightId: string;
+                content: string;
+            })[];
+            user: {
+                id: string;
+                name: string | null;
+                profilePicture: {
+                    userId: string | null;
+                    id: string;
+                    name: string;
+                    createdAt: Date;
+                    size: number;
+                    workspaceId: string | null;
+                    url: string | null;
+                    objectKey: string | null;
+                    mimeType: string;
+                    bucket: string | null;
+                    checksum: string | null;
+                    meta: import("@prisma/client/runtime/client").JsonValue | null;
+                    aiTranscription: import("@prisma/client/runtime/client").JsonValue | null;
+                } | null;
+            };
+        } & {
+            userId: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            color: string;
+            artifactVersionId: string;
+            startOffset: number;
+            endOffset: number;
+            selectedText: string;
+        })[];
+        meta: object;
+    }>;
+    createHighlight: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            artifactVersionId: string;
+            startOffset: number;
+            endOffset: number;
+            selectedText: string;
+            color?: string | undefined;
+        };
+        output: {
+            comments: {
+                userId: string;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                highlightId: string;
+                content: string;
+            }[];
+            user: {
+                id: string;
+                name: string | null;
+                profilePicture: {
+                    userId: string | null;
+                    id: string;
+                    name: string;
+                    createdAt: Date;
+                    size: number;
+                    workspaceId: string | null;
+                    url: string | null;
+                    objectKey: string | null;
+                    mimeType: string;
+                    bucket: string | null;
+                    checksum: string | null;
+                    meta: import("@prisma/client/runtime/client").JsonValue | null;
+                    aiTranscription: import("@prisma/client/runtime/client").JsonValue | null;
+                } | null;
+            };
+        } & {
+            userId: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            color: string;
+            artifactVersionId: string;
+            startOffset: number;
+            endOffset: number;
+            selectedText: string;
+        };
+        meta: object;
+    }>;
+    deleteHighlight: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            highlightId: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    addComment: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            highlightId: string;
+            content: string;
+        };
+        output: {
+            user: {
+                id: string;
+                name: string | null;
+                profilePicture: {
+                    userId: string | null;
+                    id: string;
+                    name: string;
+                    createdAt: Date;
+                    size: number;
+                    workspaceId: string | null;
+                    url: string | null;
+                    objectKey: string | null;
+                    mimeType: string;
+                    bucket: string | null;
+                    checksum: string | null;
+                    meta: import("@prisma/client/runtime/client").JsonValue | null;
+                    aiTranscription: import("@prisma/client/runtime/client").JsonValue | null;
+                } | null;
+            };
+        } & {
+            userId: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            highlightId: string;
+            content: string;
+        };
+        meta: object;
+    }>;
+    updateComment: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            commentId: string;
+            content: string;
+        };
+        output: {
+            user: {
+                id: string;
+                name: string | null;
+                profilePicture: {
+                    userId: string | null;
+                    id: string;
+                    name: string;
+                    createdAt: Date;
+                    size: number;
+                    workspaceId: string | null;
+                    url: string | null;
+                    objectKey: string | null;
+                    mimeType: string;
+                    bucket: string | null;
+                    checksum: string | null;
+                    meta: import("@prisma/client/runtime/client").JsonValue | null;
+                    aiTranscription: import("@prisma/client/runtime/client").JsonValue | null;
+                } | null;
+            };
+        } & {
+            userId: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            highlightId: string;
+            content: string;
+        };
+        meta: object;
+    }>;
+    deleteComment: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            commentId: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+}>>;

package/dist/src/routers/annotations.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { router, authedProcedure } from '../trpc.js';
+import { AnnotationService } from '../services/artifacts/annotation.service.js';
+export const annotations = router({
+    listHighlights: authedProcedure
+        .input(z.object({ artifactVersionId: z.string() }))
+        .query(({ ctx, input }) => new AnnotationService(ctx.db).listHighlights(input.artifactVersionId)),
+    createHighlight: authedProcedure
+        .input(z.object({
+        artifactVersionId: z.string(),
+        startOffset: z.number().int().min(0),
+        endOffset: z.number().int().min(0),
+        selectedText: z.string().min(1),
+        color: z.string().optional(),
+    }))
+        .mutation(({ ctx, input }) => new AnnotationService(ctx.db).createHighlight(ctx.session.user.id, input)),
+    deleteHighlight: authedProcedure
+        .input(z.object({ highlightId: z.string() }))
+        .mutation(({ ctx, input }) => new AnnotationService(ctx.db).deleteHighlight(ctx.session.user.id, input.highlightId)),
+    addComment: authedProcedure
+        .input(z.object({ highlightId: z.string(), content: z.string().min(1) }))
+        .mutation(({ ctx, input }) => new AnnotationService(ctx.db).addComment(ctx.session.user.id, input)),
+    updateComment: authedProcedure
+        .input(z.object({ commentId: z.string(), content: z.string().min(1) }))
+        .mutation(({ ctx, input }) => new AnnotationService(ctx.db).updateComment(ctx.session.user.id, input)),
+    deleteComment: authedProcedure
+        .input(z.object({ commentId: z.string() }))
+        .mutation(({ ctx, input }) => new AnnotationService(ctx.db).deleteComment(ctx.session.user.id, input.commentId)),
+});

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

@@ -0,0 +1,65 @@
+export declare const artifactVersions: 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: {
+            artifactId: string;
+        };
+        output: {
+            id: string;
+            version: number;
+            createdAt: Date;
+            isCurrent: boolean;
+            label: string | null;
+            createdBy: {
+                id: string;
+                name: string | null;
+            } | null;
+        }[];
+        meta: object;
+    }>;
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            artifactVersionId: string;
+        };
+        output: {
+            id: string;
+            artifactId: string;
+            version: number;
+            content: string;
+            data: import("@prisma/client/runtime/client").JsonValue;
+            createdAt: Date;
+            isCurrent: boolean;
+            createdBy: string | null;
+        };
+        meta: object;
+    }>;
+    restore: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            artifactVersionId: string;
+        };
+        output: {
+            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/artifactVersions.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { router, authedProcedure } from '../trpc.js';
+import { ArtifactVersionService } from '../services/artifacts/artifact-version.service.js';
+export const artifactVersions = router({
+    list: authedProcedure
+        .input(z.object({ artifactId: z.string() }))
+        .query(({ ctx, input }) => new ArtifactVersionService(ctx.db).listVersions(ctx.session.user.id, input.artifactId)),
+    get: authedProcedure
+        .input(z.object({ artifactVersionId: z.string() }))
+        .query(({ ctx, input }) => new ArtifactVersionService(ctx.db).getVersion(ctx.session.user.id, input.artifactVersionId)),
+    restore: authedProcedure
+        .input(z.object({ artifactVersionId: z.string() }))
+        .mutation(({ ctx, input }) => new ArtifactVersionService(ctx.db).restoreVersion(ctx.session.user.id, input.artifactVersionId)),
+});

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

@@ -0,0 +1,161 @@
+export declare const auth: 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<{
+    updateProfile: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+        };
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
+    changePassword: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            currentPassword: string;
+            newPassword: string;
+        };
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
+    uploadProfilePicture: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+            message: string;
+            signedUrl: string;
+        };
+        meta: object;
+    }>;
+    confirmProfileUpdate: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    signup: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+            email: string;
+            password: string;
+        };
+        output: {
+            id: string;
+            email: string | null;
+            name: string | null;
+        };
+        meta: object;
+    }>;
+    verifyEmail: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            token: string;
+        };
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
+    resendVerification: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
+    login: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+            password: string;
+        };
+        output: {
+            id: string;
+            email: string | null;
+            name: string | null;
+            token: string;
+        };
+        meta: object;
+    }>;
+    requestPasswordReset: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+        };
+        output: {
+            success: true;
+            message: string;
+        };
+        meta: object;
+    }>;
+    resetPassword: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            token: string;
+            newPassword: string;
+        };
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
+    getSession: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            user: {
+                id: string;
+                email: string | null;
+                name: string | null;
+                emailVerified: boolean;
+                profilePicture: string | null;
+                role: {
+                    id: string;
+                    name: string;
+                } | null;
+            };
+        };
+        meta: object;
+    }>;
+    requestAccountDeletion: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
+    restoreAccount: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            token: string;
+        };
+        output: {
+            success: boolean;
+            message: string;
+        };
+        meta: object;
+    }>;
+    logout: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+}>>;

package/dist/src/routers/auth.js

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { router, publicProcedure, authedProcedure } from '../trpc.js';
+import { serialize } from 'cookie';
+import { TRPCError } from '@trpc/server';
+import PusherService from '../lib/pusher.js';
+import { logger } from '../lib/logger.js';
+import { AuthService } from '../services/auth/auth.service.js';
+/**
+ * Router owns HTTP-level concerns (cookie set/clear). The service is
+ * HTTP-free and returns pure data; the router wires it into `ctx.res`.
+ */
+function getAuthCookieConfig(isProduction) {
+    return {
+        httpOnly: true,
+        secure: isProduction,
+        sameSite: (isProduction ? 'none' : 'lax'),
+        path: '/',
+        maxAge: 60 * 60 * 24 * 30,
+        domain: isProduction ? '.scribe.study' : undefined,
+    };
+}
+const passwordFieldSchema = z
+    .string()
+    .min(8, 'Password must be at least 8 characters')
+    .regex(/[A-Z]/, 'Password must contain at least one uppercase letter')
+    .regex(/[0-9]/, 'Password must contain at least one number')
+    .regex(/[^a-zA-Z0-9]/, 'Password must contain at least one special character');
+export const auth = router({
+    updateProfile: authedProcedure
+        .input(z.object({ name: z.string().min(1) }))
+        .mutation(({ ctx, input }) => new AuthService(ctx.db).updateProfile(ctx.session.user.id, input)),
+    changePassword: authedProcedure
+        .input(z.object({
+        currentPassword: z.string().min(1, 'Current password is required'),
+        newPassword: passwordFieldSchema,
+    }))
+        .mutation(({ ctx, input }) => new AuthService(ctx.db).changePassword(ctx.session.user.id, input)),
+    uploadProfilePicture: authedProcedure.mutation(({ ctx }) => new AuthService(ctx.db).uploadProfilePicture(ctx.session.user.id)),
+    confirmProfileUpdate: authedProcedure.mutation(async ({ ctx }) => {
+        logger.info(`Confirming profile update for user ${ctx.session.user.id}`, 'AUTH');
+        await PusherService.emitProfileUpdate(ctx.session.user.id);
+        return { success: true };
+    }),
+    signup: publicProcedure
+        .input(z.object({
+        name: z.string().min(1),
+        email: z.string().email(),
+        password: passwordFieldSchema,
+    }))
+        .mutation(({ ctx, input }) => new AuthService(ctx.db).signup(input)),
+    verifyEmail: publicProcedure
+        .input(z.object({ token: z.string() }))
+        .mutation(({ ctx, input }) => new AuthService(ctx.db).verifyEmail(input.token)),
+    resendVerification: publicProcedure.mutation(({ ctx }) => new AuthService(ctx.db).resendVerification(ctx.session?.user?.id)),
+    login: publicProcedure
+        .input(z.object({
+        email: z.string().email(),
+        password: z.string().min(6),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const result = await new AuthService(ctx.db).login(input);
+        const isProduction = (process.env.NODE_ENV === 'production' || process.env.RENDER);
+        const cookieValue = serialize('auth_token', result.token, getAuthCookieConfig(isProduction));
+        ctx.res.setHeader('Set-Cookie', cookieValue);
+        return result;
+    }),
+    requestPasswordReset: publicProcedure
+        .input(z.object({ email: z.string().email() }))
+        .mutation(({ ctx, input }) => new AuthService(ctx.db).requestPasswordReset(input)),
+    resetPassword: publicProcedure
+        .input(z.object({
+        token: z.string().min(1),
+        newPassword: passwordFieldSchema,
+    }))
+        .mutation(({ ctx, input }) => new AuthService(ctx.db).resetPassword(input)),
+    getSession: publicProcedure.query(({ ctx }) => new AuthService(ctx.db).getSession(ctx.session?.user?.id)),
+    requestAccountDeletion: authedProcedure.mutation(async ({ ctx }) => {
+        const result = await new AuthService(ctx.db).requestAccountDeletion(ctx.session.user.id);
+        const isProduction = (process.env.NODE_ENV === 'production' || process.env.RENDER);
+        const clearCookieConfig = getAuthCookieConfig(isProduction);
+        ctx.res.setHeader('Set-Cookie', serialize('auth_token', '', { ...clearCookieConfig, maxAge: 0 }));
+        return result;
+    }),
+    restoreAccount: publicProcedure
+        .input(z.object({ token: z.string() }))
+        .mutation(({ ctx, input }) => new AuthService(ctx.db).restoreAccount(input.token)),
+    logout: publicProcedure.mutation(async ({ ctx }) => {
+        const token = ctx.cookies['auth_token'];
+        if (!token) {
+            throw new TRPCError({ code: 'UNAUTHORIZED', message: 'No token found' });
+        }
+        const isProduction = (process.env.NODE_ENV === 'production' || process.env.RENDER);
+        const clearCookieConfig = getAuthCookieConfig(isProduction);
+        ctx.res.setHeader('Set-Cookie', serialize('auth_token', '', { ...clearCookieConfig, maxAge: 0 }));
+        return { success: true };
+    }),
+});