delete_user.ts

import admin from "firebase-admin";
import functions from "firebase-functions/v1";
import { HttpsError, onCall } from "firebase-functions/v2/https";
import { log } from "firebase-functions/logger";

const deleteUserDocument = async (
    user: admin.auth.UserRecord
): Promise<void> => {
    log(`deleteUserDocument: Deleting user document for: ${user.displayName}`);
    try {
        await admin.firestore().collection("users").doc(user.uid).delete();
    } catch (error) {
        log(
            "error: " + JSON.stringify(error, Object.getOwnPropertyNames(error))
        );
    }
};

const deleteProfileDocument = async (
    user: admin.auth.UserRecord
): Promise<void> => {
    log(`deleteProfileDocument: Deleting profile for: ${user.displayName}`);
    try {
        await admin.firestore().collection("profiles").doc(user.uid).delete();
    } catch (error) {
        log(
            "error: " + JSON.stringify(error, Object.getOwnPropertyNames(error))
        );
    }
};

const deleteUsernameDocument = async (
    user: admin.auth.UserRecord
): Promise<void> => {
    log(`deleteUsernameDocument: Deleting username of: ${user.displayName}`);
    try {
        const querySnapshot = await admin
            .firestore()
            .collection("usernames")
            .where("userUid", "==", user.uid)
            .get();
        for (const doc of querySnapshot.docs) {
            await admin.firestore().doc(doc.ref.path).delete();
        }
    } catch (error) {
        log(
            "error: " + JSON.stringify(error, Object.getOwnPropertyNames(error))
        );
    }
};

const deleteUserProjects = async (
    user: admin.auth.UserRecord
): Promise<void> => {
    log(`deleteProjects: Deleting projects created by: ${user.displayName}`);
    const batch = admin.firestore().batch();
    try {
        const allProjectsRef = await admin
            .firestore()
            .collection("projects")
            .where("userUid", "==", user.uid)
            .get();

        await Promise.all(
            allProjectsRef.docs.map(async (doc) => {
                const projectRef = admin.firestore().doc(doc.ref.path);
                const projectSubcolls = await projectRef.listCollections();

                for (const subcoll of projectSubcolls) {
                    const subcollDocs = await subcoll.get();
                    subcollDocs.forEach((subcollDoc) => {
                        batch.delete(subcollDoc.ref);
                    });
                }

                const projectLastModifiedRef = admin
                    .firestore()
                    .collection("projectLastModified")
                    .doc(projectRef.id);
                batch.delete(projectLastModifiedRef);
                batch.delete(projectRef);
            })
        );

        await batch.commit();
    } catch (error) {
        log(
            "error: " + JSON.stringify(error, Object.getOwnPropertyNames(error))
        );
    }
};

const deleteProjectsCount = async (
    user: admin.auth.UserRecord
): Promise<void> => {
    log(
        `deleteProjectsCount: Deleting projectsCount for: ${user.displayName} under ${user.uid}`
    );
    try {
        await admin
            .firestore()
            .collection("projectsCount")
            .doc(user.uid)
            .delete();
    } catch (error) {
        log(
            "error: " + JSON.stringify(error, Object.getOwnPropertyNames(error))
        );
    }
};

const cleanupDeletedUserData = async (
    user: admin.auth.UserRecord
): Promise<void> => {
    await deleteUserProjects(user);
    await deleteProfileDocument(user);
    await deleteUserDocument(user);
    await deleteUsernameDocument(user);
    await deleteProjectsCount(user);
};

export const deleteAccount = onCall({ cors: true }, async (request) => {
    const auth = request.auth;

    if (!auth?.uid) {
        throw new HttpsError("unauthenticated", "Authentication required.");
    }

    try {
        const user = await admin.auth().getUser(auth.uid);
        await cleanupDeletedUserData(user);
        await admin.auth().deleteUser(auth.uid);

        return { success: true };
    } catch (error) {
        log(
            "deleteAccount error: " +
                JSON.stringify(error, Object.getOwnPropertyNames(error || {}))
        );

        throw new HttpsError(
            "internal",
            "Failed to delete account and associated data."
        );
    }
});

export const deleteUserCallback = functions.auth
    .user()
    .onDelete(async (user) => {
        log(
            `deleteUserCallback: Removing user: ${user.displayName}, uid: ${user.uid}`
        );
        await cleanupDeletedUserData(user);

        return true;
    });