Skip to content

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!

8.2 KB
Raw Blame
import type { AuthProvider } from "@reactive-resume/auth/types";
import { ORPCError } from "@orpc/client";
import { symmetricDecrypt } from "better-auth/crypto";
import { and, eq } from "drizzle-orm";
import { auth, isCustomOAuthProviderEnabled } from "@reactive-resume/auth/config";
import { db } from "@reactive-resume/db/client";
import * as schema from "@reactive-resume/db/schema";
import { env } from "@reactive-resume/env/server";
import { isLocale } from "@reactive-resume/utils/locale";
import { applicationProfileService } from "../application-profile/service";
import { applicationLaneService } from "../applications/lanes";
import { careerService } from "../career/service";
import { coverLetterService } from "../cover-letters/service";
import { feedbackService } from "../feedback/service";
import { reportStorageCleanupSummary, runStorageCleanup } from "../storage/cleanup";
import { revokeAppleAuthorization } from "./apple-revocation";
import { exportAccountUploads } from "./export-uploads";

type ProviderList = Partial<Record<AuthProvider, string>>;

const providers = {
	list: (): ProviderList => {
		const providers: ProviderList = { credential: "Password", passkey: "Passkey" };

		if (env.APPLE_CLIENT_ID && env.APPLE_CLIENT_SECRET) providers.apple = "Apple";
		if (env.GOOGLE_CLIENT_ID && env.GOOGLE_CLIENT_SECRET) providers.google = "Google";
		if (env.GITHUB_CLIENT_ID && env.GITHUB_CLIENT_SECRET) providers.github = "GitHub";
		if (env.LINKEDIN_CLIENT_ID && env.LINKEDIN_CLIENT_SECRET) providers.linkedin = "LinkedIn";
		if (isCustomOAuthProviderEnabled()) providers.custom = env.OAUTH_PROVIDER_NAME ?? "Custom OAuth";

		return providers;
	},
};

export const authService = {
	providers,
	getProfile: async (userId: string) => {
		const [user] = await db
			.select({
				id: schema.user.id,
				name: schema.user.name,
				username: schema.user.username,
				displayUsername: schema.user.displayUsername,
				image: schema.user.image,
				email: schema.user.email,
				emailVerified: schema.user.emailVerified,
				timezone: schema.user.timezone,
				locale: schema.user.locale,
			})
			.from(schema.user)
			.where(eq(schema.user.id, userId));
		if (!user) throw new ORPCError("NOT_FOUND");
		// A value outside the supported list (none is written, but the column is free text) reads as unknown.
		return { ...user, locale: isLocale(user.locale) ? user.locale : null };
	},

	// GDPR-style export of everything the user owns. Selects explicit columns so
	// secrets (password hashes, tokens, api keys) never leak into the export.
	exportData: async (input: {
		userId: string;
		includeUploads?: boolean | undefined;
		signal?: AbortSignal | undefined;
	}) => {
		input.signal?.throwIfAborted();
		const [userRecord] = await db
			.select({
				id: schema.user.id,
				name: schema.user.name,
				email: schema.user.email,
				username: schema.user.username,
				displayUsername: schema.user.displayUsername,
				image: schema.user.image,
				timezone: schema.user.timezone,
				locale: schema.user.locale,
				emailVerified: schema.user.emailVerified,
				createdAt: schema.user.createdAt,
				updatedAt: schema.user.updatedAt,
			})
			.from(schema.user)
			.where(eq(schema.user.id, input.userId));

		if (!userRecord) throw new ORPCError("NOT_FOUND");

		const resumes = await db
			.select({
				id: schema.resume.id,
				name: schema.resume.name,
				slug: schema.resume.slug,
				tags: schema.resume.tags,
				data: schema.resume.data,
				aiOperationIds: schema.resume.aiOperationIds,
				isPublic: schema.resume.isPublic,
				showDownloadButtons: schema.resume.showDownloadButtons,
				allowWordDownload: schema.resume.allowWordDownload,
				showInSearchEngines: schema.resume.showInSearchEngines,
				hideContactDetails: schema.resume.hideContactDetails,
				isPrimary: schema.resume.isPrimary,
				isLocked: schema.resume.isLocked,
				createdAt: schema.resume.createdAt,
				updatedAt: schema.resume.updatedAt,
			})
			.from(schema.resume)
			.where(eq(schema.resume.userId, input.userId));

		const coverLetters = await db.select().from(schema.coverLetter).where(eq(schema.coverLetter.userId, input.userId));
		const applications = await db.select().from(schema.application).where(eq(schema.application.userId, input.userId));
		const resumeVersions = await db
			.select()
			.from(schema.resumeVersion)
			.where(eq(schema.resumeVersion.userId, input.userId));
		const letterVersions = await db
			.select()
			.from(schema.coverLetterVersion)
			.where(eq(schema.coverLetterVersion.userId, input.userId));
		const result = {
			exportedAt: new Date().toISOString(),
			user: userRecord,
			resumes,
			coverLetters: await Promise.all(
				coverLetters.map(({ id }) => coverLetterService.getById({ id, userId: input.userId })),
			),
			applicationPipeline: await applicationLaneService.get(input.userId),
			applications: applications.map(({ userId: _userId, ...application }) => application),
			documentVersions: {
				resumes: resumeVersions.map(({ userId: _owner, ...version }) => version),
				letters: letterVersions.map(({ userId: _owner, ...version }) => version),
			},
			aiContentReports: await db
				.select()
				.from(schema.aiContentReport)
				.where(eq(schema.aiContentReport.userId, input.userId)),
			// This existing backup section carries AI conversations; older archive clients preserve new fields here.
			career: {
				...(await careerService.exportData(input.userId)),
				aiRequests: await db
					.select({
						id: schema.aiRequest.id,
						operationId: schema.aiRequest.operationId,
						action: schema.aiRequest.action,
						providerId: schema.aiRequest.providerId,
						label: schema.aiRequest.label,
						provider: schema.aiRequest.provider,
						model: schema.aiRequest.model,
						createdAt: schema.aiRequest.createdAt,
					})
					.from(schema.aiRequest)
					.where(eq(schema.aiRequest.userId, input.userId)),
				writingReviews: await db
					.select({
						resumeId: schema.resumeWritingReview.resumeId,
						inputText: schema.resumeWritingReview.inputText,
						passages: schema.resumeWritingReview.passages,
						review: schema.resumeWritingReview.review,
						requestedAt: schema.resumeWritingReview.requestedAt,
						reviewedAt: schema.resumeWritingReview.reviewedAt,
						aiOperationId: schema.resumeWritingReview.aiOperationId,
					})
					.from(schema.resumeWritingReview)
					.where(eq(schema.resumeWritingReview.userId, input.userId)),
			},
			applicationProfile: await applicationProfileService.get(input.userId),
			feedback: await feedbackService.exportData(input.userId),
		};
		return {
			...result,
			...(input.includeUploads ? { uploads: await exportAccountUploads(input.userId, result, input.signal) } : {}),
		};
	},

	deleteAccount: async (input: { userId: string }): Promise<void> => {
		const appleAccounts = await db
			.select({ refreshToken: schema.account.refreshToken, accessToken: schema.account.accessToken })
			.from(schema.account)
			.where(and(eq(schema.account.userId, input.userId), eq(schema.account.providerId, "apple")));
		// Provider tokens are stored encrypted; rows written before that stay plaintext and fail to decrypt.
		const { secretConfig: key } = await auth.$context;
		const readToken = async (token: string | null) =>
			token && (await symmetricDecrypt({ key, data: token }).catch(() => token));
		for (const tokens of appleAccounts) {
			const plaintext = {
				refreshToken: await readToken(tokens.refreshToken),
				accessToken: await readToken(tokens.accessToken),
			};
			if (!(await revokeAppleAuthorization(plaintext))) {
				console.warn(
					"Apple authorization revocation unavailable during account deletion; manual revocation instructions apply.",
				);
			}
		}

		try {
			// A database trigger enqueues one account-prefix cleanup row in this same delete transaction, so storage
			// failures cannot leave files without a durable retry target. The row has no user FK and survives deletion.
			await db.delete(schema.user).where(eq(schema.user.id, input.userId));
		} catch (err) {
			console.error("Failed to delete user record:", err);

			throw new ORPCError("INTERNAL_SERVER_ERROR");
		}

		await runStorageCleanup({ ownerId: input.userId, limit: 1 })
			.then(reportStorageCleanupSummary)
			.catch((error: unknown) => console.warn("Account storage cleanup will retry from its durable job.", error));
	},
};