768 lines
22 KiB
TypeScript
768 lines
22 KiB
TypeScript
import {
|
|
createTRPCRouter,
|
|
publicProcedure,
|
|
protectedProcedure
|
|
} from "../utils";
|
|
import { z } from "zod";
|
|
import { ConnectionFactory } from "~/server/utils";
|
|
import { TRPCError } from "@trpc/server";
|
|
import { env } from "~/env/server";
|
|
|
|
export const databaseRouter = createTRPCRouter({
|
|
// ============================================================
|
|
// Comment Reactions Routes
|
|
// ============================================================
|
|
|
|
getCommentReactions: publicProcedure
|
|
.input(z.object({ commentID: z.string() }))
|
|
.query(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const query = "SELECT * FROM CommentReaction WHERE comment_id = ?";
|
|
const results = await conn.execute({
|
|
sql: query,
|
|
args: [input.commentID]
|
|
});
|
|
return { commentReactions: results.rows };
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to fetch comment reactions"
|
|
});
|
|
}
|
|
}),
|
|
|
|
addCommentReaction: publicProcedure
|
|
.input(
|
|
z.object({
|
|
type: z.string(),
|
|
comment_id: z.string(),
|
|
user_id: z.string()
|
|
})
|
|
)
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const query = `
|
|
INSERT INTO CommentReaction (type, comment_id, user_id)
|
|
VALUES (?, ?, ?)
|
|
`;
|
|
await conn.execute({
|
|
sql: query,
|
|
args: [input.type, input.comment_id, input.user_id]
|
|
});
|
|
|
|
const followUpQuery = `SELECT * FROM CommentReaction WHERE comment_id = ?`;
|
|
const res = await conn.execute({
|
|
sql: followUpQuery,
|
|
args: [input.comment_id]
|
|
});
|
|
|
|
return { commentReactions: res.rows };
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to add comment reaction"
|
|
});
|
|
}
|
|
}),
|
|
|
|
removeCommentReaction: publicProcedure
|
|
.input(
|
|
z.object({
|
|
type: z.string(),
|
|
comment_id: z.string(),
|
|
user_id: z.string()
|
|
})
|
|
)
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const query = `
|
|
DELETE FROM CommentReaction
|
|
WHERE type = ? AND comment_id = ? AND user_id = ?
|
|
`;
|
|
await conn.execute({
|
|
sql: query,
|
|
args: [input.type, input.comment_id, input.user_id]
|
|
});
|
|
|
|
const followUpQuery = `SELECT * FROM CommentReaction WHERE comment_id = ?`;
|
|
const res = await conn.execute({
|
|
sql: followUpQuery,
|
|
args: [input.comment_id]
|
|
});
|
|
|
|
return { commentReactions: res.rows };
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to remove comment reaction"
|
|
});
|
|
}
|
|
}),
|
|
|
|
// ============================================================
|
|
// Comments Routes
|
|
// ============================================================
|
|
|
|
getAllComments: publicProcedure.query(async () => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
// Join with Post table to get post titles along with comments
|
|
const query = `
|
|
SELECT c.*, p.title as post_title
|
|
FROM Comment c
|
|
JOIN Post p ON c.post_id = p.id
|
|
ORDER BY c.created_at DESC
|
|
`;
|
|
const res = await conn.execute(query);
|
|
return { comments: res.rows };
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to fetch comments"
|
|
});
|
|
}
|
|
}),
|
|
|
|
deleteComment: protectedProcedure
|
|
.input(
|
|
z.object({
|
|
commentID: z.number(),
|
|
commenterID: z.string(),
|
|
deletionType: z.enum(["user", "admin", "database"])
|
|
})
|
|
)
|
|
.mutation(async ({ input, ctx }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
|
|
console.log("[deleteComment] Starting deletion:", {
|
|
commentID: input.commentID,
|
|
deletionType: input.deletionType,
|
|
userId: ctx.userId,
|
|
privilegeLevel: ctx.privilegeLevel
|
|
});
|
|
|
|
// Get the comment to check ownership
|
|
const commentQuery = await conn.execute({
|
|
sql: "SELECT * FROM Comment WHERE id = ?",
|
|
args: [input.commentID]
|
|
});
|
|
|
|
const comment = commentQuery.rows[0] as any;
|
|
if (!comment) {
|
|
throw new TRPCError({
|
|
code: "NOT_FOUND",
|
|
message: "Comment not found"
|
|
});
|
|
}
|
|
|
|
// Authorization checks
|
|
const isOwner = comment.commenter_id === ctx.userId;
|
|
const isAdmin = ctx.privilegeLevel === "admin";
|
|
|
|
console.log("[deleteComment] Authorization check:", {
|
|
isOwner,
|
|
isAdmin,
|
|
commentOwner: comment.commenter_id,
|
|
requestingUser: ctx.userId
|
|
});
|
|
|
|
// User can only delete their own comments with "user" type
|
|
if (input.deletionType === "user" && !isOwner && !isAdmin) {
|
|
throw new TRPCError({
|
|
code: "FORBIDDEN",
|
|
message: "You can only delete your own comments"
|
|
});
|
|
}
|
|
|
|
// Only admins can do admin or database deletion
|
|
if (
|
|
(input.deletionType === "admin" ||
|
|
input.deletionType === "database") &&
|
|
!isAdmin
|
|
) {
|
|
throw new TRPCError({
|
|
code: "FORBIDDEN",
|
|
message: "Admin access required for this deletion type"
|
|
});
|
|
}
|
|
|
|
if (input.deletionType === "database") {
|
|
console.log("[deleteComment] Performing database deletion");
|
|
// Full deletion - remove from database
|
|
// First delete reactions
|
|
await conn.execute({
|
|
sql: "DELETE FROM CommentReaction WHERE comment_id = ?",
|
|
args: [input.commentID]
|
|
});
|
|
|
|
// Then delete the comment
|
|
await conn.execute({
|
|
sql: "DELETE FROM Comment WHERE id = ?",
|
|
args: [input.commentID]
|
|
});
|
|
|
|
console.log("[deleteComment] Database deletion successful");
|
|
return {
|
|
success: true,
|
|
deletionType: "database",
|
|
commentBody: null
|
|
};
|
|
} else if (input.deletionType === "admin") {
|
|
console.log("[deleteComment] Performing admin deletion");
|
|
// Admin delete - replace body with admin message
|
|
await conn.execute({
|
|
sql: "UPDATE Comment SET body = ?, commenter_id = ? WHERE id = ?",
|
|
args: ["[deleted by admin]", "", input.commentID]
|
|
});
|
|
|
|
console.log("[deleteComment] Admin deletion successful");
|
|
return {
|
|
success: true,
|
|
deletionType: "admin",
|
|
commentBody: "[deleted by admin]"
|
|
};
|
|
} else {
|
|
console.log("[deleteComment] Performing user deletion");
|
|
// User delete - replace body with user message
|
|
await conn.execute({
|
|
sql: "UPDATE Comment SET body = ?, commenter_id = ? WHERE id = ?",
|
|
args: ["[deleted]", "", input.commentID]
|
|
});
|
|
|
|
console.log("[deleteComment] User deletion successful");
|
|
return {
|
|
success: true,
|
|
deletionType: "user",
|
|
commentBody: "[deleted]"
|
|
};
|
|
}
|
|
} catch (error) {
|
|
console.error("[deleteComment] Failed to delete comment:", error);
|
|
if (error instanceof TRPCError) {
|
|
throw error;
|
|
}
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to delete comment"
|
|
});
|
|
}
|
|
}),
|
|
|
|
getCommentsByPostId: publicProcedure
|
|
.input(z.object({ post_id: z.string() }))
|
|
.query(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
// Join with Post table to get post titles along with comments
|
|
const query = `
|
|
SELECT c.*, p.title as post_title
|
|
FROM Comment c
|
|
JOIN Post p ON c.post_id = p.id
|
|
WHERE c.post_id = ?
|
|
ORDER BY c.created_at DESC
|
|
`;
|
|
const res = await conn.execute({
|
|
sql: query,
|
|
args: [input.post_id]
|
|
});
|
|
return { comments: res.rows };
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to fetch comments by post ID"
|
|
});
|
|
}
|
|
}),
|
|
|
|
// ============================================================
|
|
// Post Routes
|
|
// ============================================================
|
|
|
|
getPostById: publicProcedure
|
|
.input(
|
|
z.object({
|
|
category: z.literal("blog"),
|
|
id: z.number()
|
|
})
|
|
)
|
|
.query(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
// Single query with JOIN to get post and tags in one go
|
|
const query = `
|
|
SELECT p.*, t.value as tag_value
|
|
FROM Post p
|
|
LEFT JOIN Tag t ON p.id = t.post_id
|
|
WHERE p.id = ?
|
|
`;
|
|
const results = await conn.execute({
|
|
sql: query,
|
|
args: [input.id]
|
|
});
|
|
|
|
if (results.rows[0]) {
|
|
// Group tags by post ID
|
|
const post = results.rows[0];
|
|
const tags = results.rows
|
|
.filter((row) => row.tag_value)
|
|
.map((row) => row.tag_value);
|
|
|
|
return {
|
|
post,
|
|
tags
|
|
};
|
|
} else {
|
|
return { post: null, tags: [] };
|
|
}
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to fetch post by ID"
|
|
});
|
|
}
|
|
}),
|
|
|
|
getPostByTitle: publicProcedure
|
|
.input(
|
|
z.object({
|
|
category: z.literal("blog"),
|
|
title: z.string()
|
|
})
|
|
)
|
|
.query(async ({ input, ctx }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
|
|
// Get post by title with JOINs to get all related data in one query
|
|
const postQuery = `
|
|
SELECT
|
|
p.*,
|
|
COUNT(DISTINCT c.id) as comment_count,
|
|
COUNT(DISTINCT pl.user_id) as like_count,
|
|
GROUP_CONCAT(t.value) as tags
|
|
FROM Post p
|
|
LEFT JOIN Comment c ON p.id = c.post_id
|
|
LEFT JOIN PostLike pl ON p.id = pl.post_id
|
|
LEFT JOIN Tag t ON p.id = t.post_id
|
|
WHERE p.title = ? AND p.category = ? AND p.published = ?
|
|
GROUP BY p.id
|
|
`;
|
|
const postResults = await conn.execute({
|
|
sql: postQuery,
|
|
args: [input.title, input.category, true]
|
|
});
|
|
|
|
if (!postResults.rows[0]) {
|
|
return null;
|
|
}
|
|
|
|
const postRow = postResults.rows[0];
|
|
|
|
// Return structured data with proper formatting
|
|
return {
|
|
post: postRow,
|
|
comments: [], // Comments are not included in this optimized query - would need separate call if needed
|
|
likes: [], // Likes are not included in this optimized query - would need separate call if needed
|
|
tags: postRow.tags ? postRow.tags.split(",") : []
|
|
};
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to fetch post by title"
|
|
});
|
|
}
|
|
}),
|
|
|
|
createPost: publicProcedure
|
|
.input(
|
|
z.object({
|
|
category: z.literal("blog"),
|
|
title: z.string(),
|
|
subtitle: z.string().nullable(),
|
|
body: z.string().nullable(),
|
|
banner_photo: z.string().nullable(),
|
|
published: z.boolean(),
|
|
tags: z.array(z.string()).nullable(),
|
|
author_id: z.string()
|
|
})
|
|
)
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const fullURL = input.banner_photo
|
|
? env.VITE_AWS_BUCKET_STRING + input.banner_photo
|
|
: null;
|
|
|
|
const query = `
|
|
INSERT INTO Post (title, category, subtitle, body, banner_photo, published, author_id)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
`;
|
|
const params = [
|
|
input.title,
|
|
input.category,
|
|
input.subtitle,
|
|
input.body,
|
|
fullURL,
|
|
input.published,
|
|
input.author_id
|
|
];
|
|
|
|
const results = await conn.execute({ sql: query, args: params });
|
|
|
|
if (input.tags && input.tags.length > 0) {
|
|
let tagQuery = "INSERT INTO Tag (value, post_id) VALUES ";
|
|
let values = input.tags.map(
|
|
(tag) => `("${tag}", ${results.lastInsertRowid})`
|
|
);
|
|
tagQuery += values.join(", ");
|
|
await conn.execute(tagQuery);
|
|
}
|
|
|
|
return { data: results.lastInsertRowid };
|
|
} catch (error) {
|
|
console.error(error);
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to create post"
|
|
});
|
|
}
|
|
}),
|
|
|
|
updatePost: publicProcedure
|
|
.input(
|
|
z.object({
|
|
id: z.number(),
|
|
title: z.string().nullable().optional(),
|
|
subtitle: z.string().nullable().optional(),
|
|
body: z.string().nullable().optional(),
|
|
banner_photo: z.string().nullable().optional(),
|
|
published: z.boolean().nullable().optional(),
|
|
tags: z.array(z.string()).nullable().optional(),
|
|
author_id: z.string()
|
|
})
|
|
)
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
|
|
let query = "UPDATE Post SET ";
|
|
let params: any[] = [];
|
|
let first = true;
|
|
|
|
if (input.title !== undefined && input.title !== null) {
|
|
query += first ? "title = ?" : ", title = ?";
|
|
params.push(input.title);
|
|
first = false;
|
|
}
|
|
|
|
if (input.subtitle !== undefined && input.subtitle !== null) {
|
|
query += first ? "subtitle = ?" : ", subtitle = ?";
|
|
params.push(input.subtitle);
|
|
first = false;
|
|
}
|
|
|
|
if (input.body !== undefined && input.body !== null) {
|
|
query += first ? "body = ?" : ", body = ?";
|
|
params.push(input.body);
|
|
first = false;
|
|
}
|
|
|
|
if (input.banner_photo !== undefined && input.banner_photo !== null) {
|
|
query += first ? "banner_photo = ?" : ", banner_photo = ?";
|
|
if (input.banner_photo === "_DELETE_IMAGE_") {
|
|
params.push(null);
|
|
} else {
|
|
params.push(env.VITE_AWS_BUCKET_STRING + input.banner_photo);
|
|
}
|
|
first = false;
|
|
}
|
|
|
|
if (input.published !== undefined && input.published !== null) {
|
|
query += first ? "published = ?" : ", published = ?";
|
|
params.push(input.published);
|
|
first = false;
|
|
}
|
|
|
|
query += first ? "author_id = ?" : ", author_id = ?";
|
|
params.push(input.author_id);
|
|
|
|
query += " WHERE id = ?";
|
|
params.push(input.id);
|
|
|
|
const results = await conn.execute({ sql: query, args: params });
|
|
|
|
// Handle tags
|
|
const deleteTagsQuery = `DELETE FROM Tag WHERE post_id = ?`;
|
|
await conn.execute({
|
|
sql: deleteTagsQuery,
|
|
args: [input.id.toString()]
|
|
});
|
|
|
|
if (input.tags && input.tags.length > 0) {
|
|
let tagQuery = "INSERT INTO Tag (value, post_id) VALUES ";
|
|
let values = input.tags.map((tag) => `("${tag}", ${input.id})`);
|
|
tagQuery += values.join(", ");
|
|
await conn.execute(tagQuery);
|
|
}
|
|
|
|
return { data: results.lastInsertRowid };
|
|
} catch (error) {
|
|
console.error(error);
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to update post"
|
|
});
|
|
}
|
|
}),
|
|
|
|
deletePost: publicProcedure
|
|
.input(z.object({ id: z.number() }))
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
|
|
// Delete associated tags first
|
|
await conn.execute({
|
|
sql: "DELETE FROM Tag WHERE post_id = ?",
|
|
args: [input.id.toString()]
|
|
});
|
|
|
|
// Delete associated likes
|
|
await conn.execute({
|
|
sql: "DELETE FROM PostLike WHERE post_id = ?",
|
|
args: [input.id.toString()]
|
|
});
|
|
|
|
// Delete associated comments
|
|
await conn.execute({
|
|
sql: "DELETE FROM Comment WHERE post_id = ?",
|
|
args: [input.id]
|
|
});
|
|
|
|
// Finally delete the post
|
|
await conn.execute({
|
|
sql: "DELETE FROM Post WHERE id = ?",
|
|
args: [input.id]
|
|
});
|
|
|
|
return { success: true };
|
|
} catch (error) {
|
|
console.error(error);
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to delete post"
|
|
});
|
|
}
|
|
}),
|
|
|
|
// ============================================================
|
|
// Post Likes Routes
|
|
// ============================================================
|
|
|
|
addPostLike: publicProcedure
|
|
.input(
|
|
z.object({
|
|
user_id: z.string(),
|
|
post_id: z.string()
|
|
})
|
|
)
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const query = `INSERT INTO PostLike (user_id, post_id) VALUES (?, ?)`;
|
|
await conn.execute({
|
|
sql: query,
|
|
args: [input.user_id, input.post_id]
|
|
});
|
|
|
|
const followUpQuery = `SELECT * FROM PostLike WHERE post_id = ?`;
|
|
const res = await conn.execute({
|
|
sql: followUpQuery,
|
|
args: [input.post_id]
|
|
});
|
|
|
|
return { newLikes: res.rows };
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to add post like"
|
|
});
|
|
}
|
|
}),
|
|
|
|
removePostLike: publicProcedure
|
|
.input(
|
|
z.object({
|
|
user_id: z.string(),
|
|
post_id: z.string()
|
|
})
|
|
)
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const query = `
|
|
DELETE FROM PostLike
|
|
WHERE user_id = ? AND post_id = ?
|
|
`;
|
|
await conn.execute({
|
|
sql: query,
|
|
args: [input.user_id, input.post_id]
|
|
});
|
|
|
|
const followUpQuery = `SELECT * FROM PostLike WHERE post_id = ?`;
|
|
const res = await conn.execute({
|
|
sql: followUpQuery,
|
|
args: [input.post_id]
|
|
});
|
|
|
|
return { newLikes: res.rows };
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to remove post like"
|
|
});
|
|
}
|
|
}),
|
|
|
|
// ============================================================
|
|
// User Routes
|
|
// ============================================================
|
|
|
|
getUserById: publicProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.query(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const query = "SELECT * FROM User WHERE id = ?";
|
|
const res = await conn.execute({
|
|
sql: query,
|
|
args: [input.id]
|
|
});
|
|
|
|
if (res.rows[0]) {
|
|
const user = res.rows[0] as any;
|
|
if (user && user.display_name !== "user deleted") {
|
|
return {
|
|
id: user.id,
|
|
email: user.email,
|
|
emailVerified: user.email_verified,
|
|
image: user.image,
|
|
displayName: user.display_name,
|
|
provider: user.provider,
|
|
hasPassword: !!user.password_hash
|
|
};
|
|
}
|
|
}
|
|
return null;
|
|
} catch (error) {
|
|
console.error(error);
|
|
return null;
|
|
}
|
|
}),
|
|
|
|
getUserPublicData: publicProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.query(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const query =
|
|
"SELECT email, display_name, image FROM User WHERE id = ?";
|
|
const res = await conn.execute({
|
|
sql: query,
|
|
args: [input.id]
|
|
});
|
|
|
|
if (res.rows[0]) {
|
|
const user = res.rows[0] as any;
|
|
if (user && user.display_name !== "user deleted") {
|
|
return {
|
|
email: user.email,
|
|
image: user.image,
|
|
display_name: user.display_name
|
|
};
|
|
}
|
|
}
|
|
return null;
|
|
} catch (error) {
|
|
console.error(error);
|
|
return null;
|
|
}
|
|
}),
|
|
|
|
getUserImage: publicProcedure
|
|
.input(z.object({ id: z.string() }))
|
|
.query(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const query = "SELECT * FROM User WHERE id = ?";
|
|
const results = await conn.execute({
|
|
sql: query,
|
|
args: [input.id]
|
|
});
|
|
return { user: results.rows[0] };
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to fetch user image"
|
|
});
|
|
}
|
|
}),
|
|
|
|
updateUserImage: publicProcedure
|
|
.input(
|
|
z.object({
|
|
id: z.string(),
|
|
imageURL: z.string()
|
|
})
|
|
)
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const fullURL = input.imageURL
|
|
? env.VITE_AWS_BUCKET_STRING + input.imageURL
|
|
: null;
|
|
const query = `UPDATE User SET image = ? WHERE id = ?`;
|
|
await conn.execute({
|
|
sql: query,
|
|
args: [fullURL, input.id]
|
|
});
|
|
return { res: "success" };
|
|
} catch (error) {
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to update user image"
|
|
});
|
|
}
|
|
}),
|
|
|
|
updateUserEmail: publicProcedure
|
|
.input(
|
|
z.object({
|
|
id: z.string(),
|
|
newEmail: z.string().email(),
|
|
oldEmail: z.string().email()
|
|
})
|
|
)
|
|
.mutation(async ({ input }) => {
|
|
try {
|
|
const conn = ConnectionFactory();
|
|
const query = `UPDATE User SET email = ? WHERE id = ? AND email = ?`;
|
|
const res = await conn.execute({
|
|
sql: query,
|
|
args: [input.newEmail, input.id, input.oldEmail]
|
|
});
|
|
return { res };
|
|
} catch (error) {
|
|
console.error(error);
|
|
throw new TRPCError({
|
|
code: "INTERNAL_SERVER_ERROR",
|
|
message: "Failed to update user email"
|
|
});
|
|
}
|
|
})
|
|
});
|