A one-of-a-kind resume builder that keeps your privacy in mind. Completely secure, customizable, portable, open-source and free forever. Try it out today!
TypeScript agent-skillsaidsh-pluginhacktoberfestjavascriptmcp-serverreactresume-builderself-hostedtypescript
import type { DbOrTx } from "@reactive-resume/db/client";
import type { PgColumn, PgTable } from "drizzle-orm/pg-core";
import { ORPCError } from "@orpc/client";
import { and, count, desc, eq, inArray, lt, notInArray, or } from "drizzle-orm";
import { db } from "@reactive-resume/db/client";
// An editing session's autosave is refreshed at most this often.
const SESSION_REFRESH_MS = 2 * 60 * 1000;
// Expiring kinds (autosaves, restore markers, AI edits) are kept this long; the rest stay until deleted.
const RETENTION_MS = 90 * 24 * 60 * 60 * 1000;
// A safety cap per expiring kind (autosaves, AI edits, restore markers) and document, so storage stays bounded
// however often it's edited.
const MAX_AUTOSAVES = 500;
// Named versions stay until deleted, so their number is capped instead.
const MAX_NAMED = 200;
// Bound recent expiring versions; permanent checkpoints always remain discoverable.
const LIST_LIMIT = 100;
type VersionSummary<TKind extends string> = { id: string; kind: TKind; name: string | null; createdAt: Date };
type VersionTable = {
table: PgTable;
id: PgColumn;
/** The document the version belongs to (`resumeId`, `coverLetterId`). */
document: PgColumn;
documentKey: string;
userId: PgColumn;
data: PgColumn;
aiOperationIds?: PgColumn;
kind: PgColumn;
name: PgColumn;
sessionId: PgColumn;
createdAt: PgColumn;
};
type Owned = { documentId: string; userId: string };
/**
* History for one kind of document (resumes, letters): versions are written with a kind, autosaves collapse into one
* per editing session, expiring kinds age out after 90 days, and only named versions can be renamed or deleted.
* Retention runs whenever a version is written, so it needs no scheduler.
*/
export function createVersionHistory<TKind extends string, TData>(config: {
versions: VersionTable;
/** The document table, for the ownership check before listing. */
owner: { table: PgTable; id: PgColumn; userId: PgColumn };
expiringKinds: readonly TKind[];
/** Every write stores data through this (validation, normalisation). */
toStored: (data: TData) => unknown;
label: string;
}) {
const v = config.versions;
const summary = { id: v.id, kind: v.kind, name: v.name, createdAt: v.createdAt };
const stored = (input: { data: TData; aiOperationIds?: string[] | undefined }) => ({
data: config.toStored(input.data),
...(v.aiOperationIds ? { aiOperationIds: input.aiOperationIds ?? [] } : {}),
});
const ownedVersion = (input: Owned & { versionId: string }) =>
and(eq(v.id, input.versionId), eq(v.document, input.documentId), eq(v.userId, input.userId));
async function prune(client: DbOrTx, documentId: string) {
await client
.delete(v.table)
.where(
and(
eq(v.document, documentId),
inArray(v.kind, [...config.expiringKinds]),
lt(v.createdAt, new Date(Date.now() - RETENTION_MS)),
),
);
// Restore markers are kept past retention but are capped like the expiring kinds.
for (const kind of [...config.expiringKinds, "before-restore"]) {
const newest = client
.select({ id: v.id })
.from(v.table)
.where(and(eq(v.document, documentId), eq(v.kind, kind)))
.orderBy(desc(v.createdAt))
.limit(MAX_AUTOSAVES);
await client.delete(v.table).where(and(eq(v.document, documentId), eq(v.kind, kind), notInArray(v.id, newest)));
}
}
async function write(
client: DbOrTx,
input: Owned & {
data: TData;
aiOperationIds?: string[] | undefined;
kind: TKind;
name?: string | null | undefined;
sessionId?: string | undefined;
},
) {
if (input.kind === "named") {
const [named] = await client
.select({ total: count() })
.from(v.table)
.where(and(eq(v.document, input.documentId), eq(v.userId, input.userId), eq(v.kind, "named")));
if ((named?.total ?? 0) >= MAX_NAMED)
throw new ORPCError("BAD_REQUEST", {
message: `A document can keep ${MAX_NAMED} saved versions. Delete one you no longer need first.`,
});
}
const [version] = await client
.insert(v.table)
.values({
[v.documentKey]: input.documentId,
userId: input.userId,
...stored(input),
kind: input.kind,
name: input.name ?? null,
sessionId: input.sessionId ?? null,
} as never)
.returning(summary);
if (!version) throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "Couldn't save the version. Try again." });
await prune(client, input.documentId);
return version as VersionSummary<TKind>;
}
return {
write,
/**
* The autosave path. Each editing session keeps one version holding its latest state, refreshed at most every
* two minutes. Callers that send no session (API clients) get a new autosave once the newest version is two
* minutes old. Best effort: it never fails or delays the save beyond its own queries.
*/
async saveSession(
input: Owned & { data: TData; aiOperationIds?: string[] | undefined; sessionId?: string | undefined },
) {
try {
const [latest] = await db
.select({ id: v.id, createdAt: v.createdAt })
.from(v.table)
.where(
and(
eq(v.document, input.documentId),
...(input.sessionId ? [eq(v.kind, "auto"), eq(v.sessionId, input.sessionId)] : []),
),
)
.orderBy(desc(v.createdAt))
.limit(1);
if (latest && Date.now() - (latest.createdAt as Date).getTime() < SESSION_REFRESH_MS) return;
if (latest && input.sessionId) {
await db
.update(v.table)
.set({ ...stored(input), createdAt: new Date() } as never)
.where(eq(v.id, latest.id));
return;
}
await write(db, { ...input, kind: "auto" as TKind });
} catch (error) {
console.warn(`Failed to save the ${config.label}'s session version:`, error);
}
},
async list(input: Owned) {
const [owner] = await db
.select({ id: config.owner.id })
.from(config.owner.table)
.where(and(eq(config.owner.id, input.documentId), eq(config.owner.userId, input.userId)));
if (!owner) throw new ORPCError("NOT_FOUND");
const recent = db
.select({ id: v.id })
.from(v.table)
.where(
and(eq(v.document, input.documentId), eq(v.userId, input.userId), inArray(v.kind, [...config.expiringKinds])),
)
.orderBy(desc(v.createdAt))
.limit(LIST_LIMIT);
const versions = await db
.select(summary)
.from(v.table)
.where(
and(
eq(v.document, input.documentId),
eq(v.userId, input.userId),
or(notInArray(v.kind, [...config.expiringKinds]), inArray(v.id, recent)),
),
)
.orderBy(desc(v.createdAt));
return versions as VersionSummary<TKind>[];
},
async get(input: Owned & { versionId: string }) {
const [version] = await db
.select({ ...summary, data: v.data, ...(v.aiOperationIds ? { aiOperationIds: v.aiOperationIds } : {}) })
.from(v.table)
.where(ownedVersion(input));
if (!version) throw new ORPCError("NOT_FOUND");
return version as VersionSummary<TKind> & { data: unknown; aiOperationIds?: string[] };
},
/** Named versions are the user's own; only they can be renamed or deleted. */
async rename(input: Owned & { versionId: string; name: string }) {
const [version] = await db
.update(v.table)
.set({ name: input.name } as never)
.where(and(ownedVersion(input), eq(v.kind, "named")))
.returning(summary);
if (!version) throw new ORPCError("NOT_FOUND");
return version as VersionSummary<TKind>;
},
async remove(input: Owned & { versionId: string }) {
const [version] = await db
.delete(v.table)
.where(and(ownedVersion(input), eq(v.kind, "named")))
.returning({ id: v.id });
if (!version) throw new ORPCError("NOT_FOUND");
},
};
}