openmonetis/lib/pagadores/access.ts

import { and, eq } from "drizzle-orm";
import { pagadores, pagadorShares, user as usersTable } from "@/db/schema";
import { db } from "@/lib/db";

export type PagadorWithAccess = typeof pagadores.$inferSelect & {
	canEdit: boolean;
	sharedByName: string | null;
	sharedByEmail: string | null;
	shareId: string | null;
};

export async function fetchPagadoresWithAccess(
	userId: string,
): Promise<PagadorWithAccess[]> {
	const [owned, shared] = await Promise.all([
		db.query.pagadores.findMany({
			where: eq(pagadores.userId, userId),
		}),
		db
			.select({
				shareId: pagadorShares.id,
				pagador: pagadores,
				ownerName: usersTable.name,
				ownerEmail: usersTable.email,
			})
			.from(pagadorShares)
			.innerJoin(pagadores, eq(pagadorShares.pagadorId, pagadores.id))
			.leftJoin(usersTable, eq(pagadores.userId, usersTable.id))
			.where(eq(pagadorShares.sharedWithUserId, userId)),
	]);

	const ownedMapped: PagadorWithAccess[] = owned.map((item) => ({
		...item,
		canEdit: true,
		sharedByName: null,
		sharedByEmail: null,
		shareId: null,
	}));

	const sharedMapped: PagadorWithAccess[] = shared.map((item) => ({
		...item.pagador,
		shareCode: null,
		canEdit: false,
		sharedByName: item.ownerName ?? null,
		sharedByEmail: item.ownerEmail ?? null,
		shareId: item.shareId,
	}));

	return [...ownedMapped, ...sharedMapped];
}

export async function getPagadorAccess(userId: string, pagadorId: string) {
	const pagador = await db.query.pagadores.findFirst({
		where: and(eq(pagadores.id, pagadorId)),
	});

	if (!pagador) {
		return null;
	}

	if (pagador.userId === userId) {
		return {
			pagador,
			canEdit: true,
			share: null as typeof pagadorShares.$inferSelect | null,
		};
	}

	const share = await db.query.pagadorShares.findFirst({
		where: and(
			eq(pagadorShares.pagadorId, pagadorId),
			eq(pagadorShares.sharedWithUserId, userId),
		),
	});

	if (!share) {
		return null;
	}

	return { pagador, canEdit: false, share };
}

export async function userCanEditPagador(userId: string, pagadorId: string) {
	const pagadorRow = await db.query.pagadores.findFirst({
		columns: { id: true },
		where: and(eq(pagadores.id, pagadorId), eq(pagadores.userId, userId)),
	});

	return Boolean(pagadorRow);
}

export async function userHasPagadorAccess(userId: string, pagadorId: string) {
	const access = await getPagadorAccess(userId, pagadorId);
	return Boolean(access);
}