313 lines
8.3 KiB
TypeScript
313 lines
8.3 KiB
TypeScript
import { createTRPCRouter, publicProcedure } from "../utils";
|
|
import { ConnectionFactory } from "~/server/utils";
|
|
import { z } from "zod";
|
|
import { getUserID } from "~/server/auth";
|
|
import { TRPCError } from "@trpc/server";
|
|
import diff from "fast-diff";
|
|
|
|
// Helper to create diff patch between two HTML strings
|
|
export function createDiffPatch(
|
|
oldContent: string,
|
|
newContent: string
|
|
): string {
|
|
const changes = diff(oldContent, newContent);
|
|
return JSON.stringify(changes);
|
|
}
|
|
|
|
// Helper to apply diff patch to content
|
|
export function applyDiffPatch(baseContent: string, patchJson: string): string {
|
|
const changes = JSON.parse(patchJson);
|
|
let result = "";
|
|
let position = 0;
|
|
|
|
for (const [operation, text] of changes) {
|
|
if (operation === diff.EQUAL) {
|
|
result += text;
|
|
position += text.length;
|
|
} else if (operation === diff.DELETE) {
|
|
position += text.length;
|
|
} else if (operation === diff.INSERT) {
|
|
result += text;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Helper to reconstruct content from history chain
|
|
async function reconstructContent(
|
|
conn: ReturnType<typeof ConnectionFactory>,
|
|
historyId: number
|
|
): Promise<string> {
|
|
// Get the full chain from root to this history entry
|
|
const chain: Array<{
|
|
id: number;
|
|
parent_id: number | null;
|
|
content: string;
|
|
}> = [];
|
|
|
|
let currentId: number | null = historyId;
|
|
|
|
while (currentId !== null) {
|
|
const result = await conn.execute({
|
|
sql: "SELECT id, parent_id, content FROM PostHistory WHERE id = ?",
|
|
args: [currentId]
|
|
});
|
|
|
|
if (result.rows.length === 0) {
|
|
throw new TRPCError({
|
|
code: "NOT_FOUND",
|
|
message: "History entry not found"
|
|
});
|
|
}
|
|
|
|
const row = result.rows[0] as {
|
|
id: number;
|
|
parent_id: number | null;
|
|
content: string;
|
|
};
|
|
chain.unshift(row);
|
|
currentId = row.parent_id;
|
|
}
|
|
|
|
// Apply patches in order
|
|
let content = "";
|
|
for (const entry of chain) {
|
|
content = applyDiffPatch(content, entry.content);
|
|
}
|
|
|
|
return content;
|
|
}
|
|
|
|
export const postHistoryRouter = createTRPCRouter({
|
|
// Save a new history entry
|
|
save: publicProcedure
|
|
.input(
|
|
z.object({
|
|
postId: z.number(),
|
|
content: z.string(),
|
|
previousContent: z.string(),
|
|
parentHistoryId: z.number().nullable(),
|
|
isSaved: z.boolean().default(false)
|
|
})
|
|
)
|
|
.mutation(async ({ input, ctx }) => {
|
|
const userId = await getUserID(ctx.event.nativeEvent);
|
|
|
|
if (!userId) {
|
|
throw new TRPCError({
|
|
code: "UNAUTHORIZED",
|
|
message: "Must be authenticated to save history"
|
|
});
|
|
}
|
|
|
|
const conn = ConnectionFactory();
|
|
|
|
// Verify post exists and user is author
|
|
const postCheck = await conn.execute({
|
|
sql: "SELECT author_id FROM Post WHERE id = ?",
|
|
args: [input.postId]
|
|
});
|
|
|
|
if (postCheck.rows.length === 0) {
|
|
throw new TRPCError({
|
|
code: "NOT_FOUND",
|
|
message: "Post not found"
|
|
});
|
|
}
|
|
|
|
const post = postCheck.rows[0] as { author_id: string };
|
|
if (post.author_id !== userId) {
|
|
throw new TRPCError({
|
|
code: "FORBIDDEN",
|
|
message: "Not authorized to modify this post"
|
|
});
|
|
}
|
|
|
|
// Create diff patch
|
|
const diffPatch = createDiffPatch(input.previousContent, input.content);
|
|
|
|
// Insert history entry
|
|
const result = await conn.execute({
|
|
sql: `
|
|
INSERT INTO PostHistory (post_id, parent_id, content, is_saved)
|
|
VALUES (?, ?, ?, ?)
|
|
`,
|
|
args: [
|
|
input.postId,
|
|
input.parentHistoryId,
|
|
diffPatch,
|
|
input.isSaved ? 1 : 0
|
|
]
|
|
});
|
|
|
|
// Prune old history entries if we exceed 100
|
|
const countResult = await conn.execute({
|
|
sql: "SELECT COUNT(*) as count FROM PostHistory WHERE post_id = ?",
|
|
args: [input.postId]
|
|
});
|
|
|
|
const count = (countResult.rows[0] as { count: number }).count;
|
|
if (count > 100) {
|
|
// Get the oldest entries to delete (keep most recent 100)
|
|
const toDelete = await conn.execute({
|
|
sql: `
|
|
SELECT id FROM PostHistory
|
|
WHERE post_id = ?
|
|
ORDER BY created_at ASC
|
|
LIMIT ?
|
|
`,
|
|
args: [input.postId, count - 100]
|
|
});
|
|
|
|
// Delete old entries
|
|
for (const row of toDelete.rows) {
|
|
const entry = row as { id: number };
|
|
await conn.execute({
|
|
sql: "DELETE FROM PostHistory WHERE id = ?",
|
|
args: [entry.id]
|
|
});
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
historyId: Number(result.lastInsertRowid)
|
|
};
|
|
}),
|
|
|
|
// Get history for a post with reconstructed content
|
|
getHistory: publicProcedure
|
|
.input(z.object({ postId: z.number() }))
|
|
.query(async ({ input, ctx }) => {
|
|
const userId = await getUserID(ctx.event.nativeEvent);
|
|
|
|
if (!userId) {
|
|
throw new TRPCError({
|
|
code: "UNAUTHORIZED",
|
|
message: "Must be authenticated to view history"
|
|
});
|
|
}
|
|
|
|
const conn = ConnectionFactory();
|
|
|
|
// Verify post exists and user is author
|
|
const postCheck = await conn.execute({
|
|
sql: "SELECT author_id FROM Post WHERE id = ?",
|
|
args: [input.postId]
|
|
});
|
|
|
|
if (postCheck.rows.length === 0) {
|
|
throw new TRPCError({
|
|
code: "NOT_FOUND",
|
|
message: "Post not found"
|
|
});
|
|
}
|
|
|
|
const post = postCheck.rows[0] as { author_id: string };
|
|
if (post.author_id !== userId) {
|
|
throw new TRPCError({
|
|
code: "FORBIDDEN",
|
|
message: "Not authorized to view this post's history"
|
|
});
|
|
}
|
|
|
|
// Get all history entries for this post
|
|
const result = await conn.execute({
|
|
sql: `
|
|
SELECT id, parent_id, content, created_at, is_saved
|
|
FROM PostHistory
|
|
WHERE post_id = ?
|
|
ORDER BY created_at ASC
|
|
`,
|
|
args: [input.postId]
|
|
});
|
|
|
|
const entries = result.rows as Array<{
|
|
id: number;
|
|
parent_id: number | null;
|
|
content: string;
|
|
created_at: string;
|
|
is_saved: number;
|
|
}>;
|
|
|
|
// Reconstruct content for each entry by applying diffs sequentially
|
|
const historyWithContent: Array<{
|
|
id: number;
|
|
parent_id: number | null;
|
|
content: string;
|
|
created_at: string;
|
|
is_saved: number;
|
|
}> = [];
|
|
|
|
let accumulatedContent = "";
|
|
for (const entry of entries) {
|
|
accumulatedContent = applyDiffPatch(accumulatedContent, entry.content);
|
|
historyWithContent.push({
|
|
id: entry.id,
|
|
parent_id: entry.parent_id,
|
|
content: accumulatedContent,
|
|
created_at: entry.created_at,
|
|
is_saved: entry.is_saved
|
|
});
|
|
}
|
|
|
|
return historyWithContent;
|
|
}),
|
|
|
|
// Restore content from a history entry
|
|
restore: publicProcedure
|
|
.input(z.object({ historyId: z.number() }))
|
|
.query(async ({ input, ctx }) => {
|
|
const userId = await getUserID(ctx.event.nativeEvent);
|
|
|
|
if (!userId) {
|
|
throw new TRPCError({
|
|
code: "UNAUTHORIZED",
|
|
message: "Must be authenticated to restore history"
|
|
});
|
|
}
|
|
|
|
const conn = ConnectionFactory();
|
|
|
|
// Get history entry and verify ownership
|
|
const historyResult = await conn.execute({
|
|
sql: `
|
|
SELECT ph.post_id
|
|
FROM PostHistory ph
|
|
JOIN Post p ON ph.post_id = p.id
|
|
WHERE ph.id = ?
|
|
`,
|
|
args: [input.historyId]
|
|
});
|
|
|
|
if (historyResult.rows.length === 0) {
|
|
throw new TRPCError({
|
|
code: "NOT_FOUND",
|
|
message: "History entry not found"
|
|
});
|
|
}
|
|
|
|
const historyEntry = historyResult.rows[0] as { post_id: number };
|
|
|
|
// Verify user is post author
|
|
const postCheck = await conn.execute({
|
|
sql: "SELECT author_id FROM Post WHERE id = ?",
|
|
args: [historyEntry.post_id]
|
|
});
|
|
|
|
const post = postCheck.rows[0] as { author_id: string };
|
|
if (post.author_id !== userId) {
|
|
throw new TRPCError({
|
|
code: "FORBIDDEN",
|
|
message: "Not authorized to restore this post's history"
|
|
});
|
|
}
|
|
|
|
// Reconstruct content from history chain
|
|
const content = await reconstructContent(conn, input.historyId);
|
|
|
|
return { content };
|
|
})
|
|
});
|