Campus-scoped staff: schema, campusScope helper, route test, first 79 routes

UserCampusScope relation and audit action; scopeEvent/scopeList/unscopedOnly/
campusIndependent/scopeBroadcast markers; tests/campusScopeRoutes.test.js
(still failing: events, payments, registrations, scan locks, tickets left).
Can't delete a campus that has scoped staff.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-27 17:28:30 +02:00
co-authored by Claude Opus 5.5
parent ab4152960b
commit 2ac2ec36e0
36 changed files with 494 additions and 115 deletions
@@ -0,0 +1,19 @@
-- AlterEnum
ALTER TYPE "AdminAuditAction" ADD VALUE 'user_campus_scope_changed';
-- CreateTable
CREATE TABLE "_UserCampusScope" (
"A" TEXT NOT NULL,
"B" TEXT NOT NULL,
CONSTRAINT "_UserCampusScope_AB_pkey" PRIMARY KEY ("A","B")
);
-- CreateIndex
CREATE INDEX "_UserCampusScope_B_index" ON "_UserCampusScope"("B");
-- AddForeignKey
ALTER TABLE "_UserCampusScope" ADD CONSTRAINT "_UserCampusScope_A_fkey" FOREIGN KEY ("A") REFERENCES "Campus"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "_UserCampusScope" ADD CONSTRAINT "_UserCampusScope_B_fkey" FOREIGN KEY ("B") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+6
View File
@@ -146,6 +146,10 @@ model User {
homeCampusId String?
homeCampus Campus? @relation("UserHomeCampus", fields: [homeCampusId], references: [id], onDelete: SetNull)
campusSummaries Campus[] @relation("CampusNotifyRecipients")
// Campus-scoped staff (1.44.0): a supervisor/staff member limited to these campuses (their
// events plus events for all campuses). Empty = unscoped. Ignored for admins and while
// campuses are off (utils/campusScope.js).
scopedCampuses Campus[] @relation("UserCampusScope")
@@index([homeCampusId])
}
@@ -174,6 +178,7 @@ model Campus {
homeOf User[] @relation("UserHomeCampus")
// Get the daily summary for this campus's events (on top of each event's own recipients).
notifyRecipients User[] @relation("CampusNotifyRecipients")
scopedStaff User[] @relation("UserCampusScope")
@@index([order])
}
@@ -649,6 +654,7 @@ enum AdminAuditAction {
campus_archived
campus_deleted
event_campus_changed
user_campus_scope_changed
}
// Append-only audit trail for admin/supervisor-initiated actions with money or
@@ -21,9 +21,13 @@ const trackStage = async (req, res) => {
// @access Private/Supervisor
const getFunnel = async (req, res) => {
try {
const eventIds = String(req.query.eventIds || '').split(',').map(s => s.trim()).filter(Boolean).slice(0, 50);
if (eventIds.length === 0) { res.status(400); throw new Error('Choose at least one event'); }
const events = await prisma.event.findMany({ where: { id: { in: eventIds } }, select: { id: true, title: true } });
const asked = String(req.query.eventIds || '').split(',').map(s => s.trim()).filter(Boolean).slice(0, 50);
if (asked.length === 0) { res.status(400); throw new Error('Choose at least one event'); }
// Campus-scoped supervisors only get the events they can see.
const scopeWhere = await require('../utils/campusScope').listWhere(req);
const events = await prisma.event.findMany({ where: { id: { in: asked }, ...scopeWhere }, select: { id: true, title: true } });
const eventIds = events.map(e => e.id);
if (eventIds.length === 0) { res.status(404); throw new Error('Event not found'); }
const total = await funnelFor(eventIds, { from: req.query.from, to: req.query.to });
// Per event too, so events can be compared.
const perEvent = [];
@@ -17,7 +17,7 @@ function friendlyError(e) {
const ADMIN_INCLUDE = {
notifyRecipients: { select: { id: true, name: true, email: true } },
_count: { select: { events: true, homeOf: true } },
_count: { select: { events: true, homeOf: true, scopedStaff: true } },
};
// @desc Whether campuses are on, and the active campuses (public site filters, event cards)
@@ -151,8 +151,12 @@ const reorderCampuses = async (req, res) => {
// @access Private/Admin
const deleteCampus = async (req, res) => {
try {
const campus = await prisma.campus.findUnique({ where: { id: req.params.id }, include: { _count: { select: { events: true } } } });
const campus = await prisma.campus.findUnique({ where: { id: req.params.id }, include: { _count: { select: { events: true, scopedStaff: true } } } });
if (!campus) return res.status(404).json({ message: 'Campus not found' });
// Deleting would drop their limit and leave them unscoped (seeing every campus).
if (campus._count.scopedStaff > 0) {
return res.status(409).json({ code: 'CAMPUS_HAS_SCOPED_STAFF', message: `${campus._count.scopedStaff} staff member${campus._count.scopedStaff === 1 ? ' is' : 's are'} limited to ${campus.name}. Change their campuses in Admin → Users first, or archive the campus.` });
}
if (campus._count.events > 0) {
return res.status(409).json({ code: 'CAMPUS_HAS_EVENTS', message: `${campus.name} has ${campus._count.events} event${campus._count.events === 1 ? '' : 's'}, so it can't be deleted. Archive it instead.` });
}
@@ -173,6 +177,8 @@ const getCampusAudience = async (req, res) => {
try {
const campus = await prisma.campus.findUnique({ where: { id: req.params.id }, select: { id: true, name: true } });
if (!campus) return res.status(404).json({ message: 'Campus not found' });
const scope = await require('../utils/campusScope').scopeFor(req);
if (scope && !scope.campusIds.includes(campus.id)) return res.status(404).json({ message: 'Campus not found' });
const users = await prisma.user.findMany({
where: campusAudienceWhere(campus.id, { includeRegistrants: req.query.registrants === 'true' }),
select: { id: true, name: true, email: true, phoneNumber: true },
@@ -291,9 +291,12 @@ const resolvePending = async (req, res) => {
const getCashupAudit = async (req, res) => {
try {
const { eventId, from, to } = req.query;
// Campus-scoped supervisors only see cashups they could do: their campuses' events.
const scope = await require('../utils/campusScope').scopeFor(req);
const where = {};
if (eventId) where.eventId = eventId;
if (scope) where.event = require('../utils/campusScope').manageWhere(scope);
if (from || to) {
where.createdAt = {};
if (from) where.createdAt.gte = new Date(from);
@@ -5,18 +5,29 @@ const { getClientIp } = require('../utils/requestUtils');
const { normalizeCode, previewCoupon, buildCouponLines, describeCoupon, countCouponUses } = require('../utils/coupons');
const { resolveOptionPrice, resolveVariantTierPrice } = require('../utils/pricing');
const { describeBundle } = require('../utils/bundles');
const { scopeFor, couponAllowed, listWhere } = require('../utils/campusScope');
const TYPES = ['percent', 'fixed', 'comp'];
const ROLES = ['user', 'staff', 'supervisor', 'admin'];
const STAFF_ROLES = ['staff', 'supervisor', 'admin'];
const COUPON_DETAIL_INCLUDE = {
events: { include: { event: { select: { id: true, title: true, startDate: true } } } },
events: { include: { event: { select: { id: true, title: true, startDate: true, campusId: true } } } },
options: { include: { eventOption: { select: { id: true, name: true, eventId: true } }, variant: { select: { id: true, name: true } } } },
allowedUsers: { include: { user: { select: { id: true, name: true, email: true } } } },
createdBy: { select: { id: true, name: true } },
};
// Campus-scoped supervisors: only coupons limited to events at their campuses (couponAllowed).
const couponCampuses = coupon => (coupon.events || []).map(ce => ce.event?.campusId ?? null);
async function eventIdsAllowed(scope, eventIds) {
if (!scope) return true;
if (!eventIds || eventIds.length === 0) return false; // a coupon for every event
const events = await prisma.event.findMany({ where: { id: { in: eventIds } }, select: { campusId: true } });
return events.length === eventIds.length && couponAllowed(scope, events.map(e => e.campusId));
}
const SCOPED_COUPON_MSG = 'Supervisors for some campuses can only make coupons limited to events at their campuses.';
const optionalDate = (v, label) => {
if (v === undefined) return undefined;
if (v === null || v === '') return null;
@@ -119,7 +130,9 @@ function relationWrites({ eventIds, scopes, userIds }, isCreate) {
// @access Private/Supervisor
const listCoupons = async (req, res) => {
try {
const coupons = await prisma.coupon.findMany({ include: COUPON_DETAIL_INCLUDE, orderBy: { createdAt: 'desc' } });
const scope = await scopeFor(req);
const coupons = (await prisma.coupon.findMany({ include: COUPON_DETAIL_INCLUDE, orderBy: { createdAt: 'desc' } }))
.filter(c => couponAllowed(scope, couponCampuses(c)));
const totals = await prisma.couponRedemption.groupBy({
by: ['couponId'],
where: { releasedAt: null, registration: { status: { not: 'cancelled' } } },
@@ -157,7 +170,7 @@ const getCoupon = async (req, res) => {
},
},
});
if (!coupon) { res.status(404); throw new Error('Coupon not found'); }
if (!coupon || !couponAllowed(await scopeFor(req), couponCampuses(coupon))) { res.status(404); throw new Error('Coupon not found'); }
res.json({ ...coupon, summary: describeCoupon(coupon) });
} catch (error) {
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
@@ -173,6 +186,7 @@ const createCoupon = async (req, res) => {
try {
parsed = await parseCouponBody(req.body || {}, { isCreate: true });
} catch (e) { res.status(400); throw e; }
if (!(await eventIdsAllowed(await scopeFor(req), parsed.eventIds))) { res.status(403); throw new Error(SCOPED_COUPON_MSG); }
if (await prisma.coupon.findUnique({ where: { code: parsed.data.code } })) {
res.status(409); throw new Error(`The code ${parsed.data.code} already exists`);
}
@@ -198,12 +212,14 @@ const createCoupon = async (req, res) => {
// @access Private/Supervisor
const updateCoupon = async (req, res) => {
try {
const existing = await prisma.coupon.findUnique({ where: { id: req.params.id } });
if (!existing) { res.status(404); throw new Error('Coupon not found'); }
const existing = await prisma.coupon.findUnique({ where: { id: req.params.id }, include: { events: { include: { event: { select: { campusId: true } } } } } });
const scope = await scopeFor(req);
if (!existing || !couponAllowed(scope, couponCampuses(existing))) { res.status(404); throw new Error('Coupon not found'); }
let parsed;
try {
parsed = await parseCouponBody({ type: existing.type, ...req.body }, { isCreate: false });
} catch (e) { res.status(400); throw e; }
if (parsed.eventIds !== undefined && !(await eventIdsAllowed(scope, parsed.eventIds))) { res.status(403); throw new Error(SCOPED_COUPON_MSG); }
if (parsed.data.code && parsed.data.code !== existing.code) {
const used = await prisma.couponRedemption.count({ where: { couponId: existing.id } });
if (used > 0) { res.status(400); throw new Error('This code has been used, so it can\'t be renamed. Turn it off and create a new one instead.'); }
@@ -327,9 +343,10 @@ const listRedemptions = async (req, res) => {
const eventIds = String(req.query.eventIds || '').split(',').map(s => s.trim()).filter(Boolean);
const from = req.query.from ? new Date(req.query.from) : null;
const to = req.query.to ? new Date(req.query.to) : null;
const scopeEvent = await listWhere(req, 'event'); // { event: … } or {}
const where = {
releasedAt: null,
registration: { status: { not: 'cancelled' }, ...(eventIds.length ? { eventId: { in: eventIds } } : {}) },
registration: { status: { not: 'cancelled' }, ...(eventIds.length ? { eventId: { in: eventIds } } : {}), ...scopeEvent },
...(from || to ? { createdAt: { ...(from && !isNaN(from) ? { gte: from } : {}), ...(to && !isNaN(to) ? { lte: to } : {}) } } : {}),
};
const rows = await prisma.couponRedemption.findMany({
@@ -346,7 +363,7 @@ const listRedemptions = async (req, res) => {
// discounts are recalculated, so dates go by when the registration was made.
const regDate = from || to ? { createdAt: { ...(from && !isNaN(from) ? { gte: from } : {}), ...(to && !isNaN(to) ? { lte: to } : {}) } } : {};
const bundleRows = await prisma.registrationBundle.findMany({
where: { registration: { status: { not: 'cancelled' }, ...(eventIds.length ? { eventId: { in: eventIds } } : {}), ...regDate } },
where: { registration: { status: { not: 'cancelled' }, ...(eventIds.length ? { eventId: { in: eventIds } } : {}), ...regDate, ...scopeEvent } },
include: {
bundle: { include: { items: { include: { eventOption: { select: { name: true } }, variant: { select: { name: true } } } } } },
registration: { select: { id: true, status: true, createdAt: true, user: { select: { id: true, name: true, email: true } }, event: { select: { id: true, title: true } } } },
@@ -151,7 +151,7 @@ const getSummary = async (req, res) => {
try {
const ids = String(req.query.eventIds || '').split(',').map(s => s.trim()).filter(Boolean).slice(0, 50);
const forms = await prisma.feedbackForm.findMany({
where: { eventId: { in: ids } },
where: { eventId: { in: ids }, ...(await require('../utils/campusScope').listWhere(req, 'event')) },
include: {
event: { select: { id: true, title: true, startDate: true } },
fields: { orderBy: { order: 'asc' } },
@@ -16,6 +16,7 @@ const listFormResponses = async (req, res) => {
const registrationFilter = {};
if (eventId) registrationFilter.eventId = String(eventId);
if (userId) registrationFilter.userId = String(userId);
Object.assign(registrationFilter, await require('../utils/campusScope').listWhere(req, 'event'));
if (Object.keys(registrationFilter).length > 0) {
// Prisma relation filter requires `is` wrapper
where.registration = { is: registrationFilter };
@@ -1,4 +1,20 @@
const { listJobs, getJob, updateJob, deleteJob } = require('../utils/scheduledEmails');
const prisma = require('../config/db');
const { scopeFor, eventWhere } = require('../utils/campusScope');
/**
* The jobs a campus-scoped supervisor may see and change: messages for events they can see, and
* broadcasts they scheduled themselves. Everyone else sees every job.
*/
async function visibleJobs(req, jobs) {
const scope = await scopeFor(req);
if (!scope) return jobs;
const ids = [...new Set(jobs.map(j => j.eventId).filter(Boolean))];
const seen = ids.length
? new Set((await prisma.event.findMany({ where: { id: { in: ids }, ...eventWhere(scope) }, select: { id: true } })).map(e => e.id))
: new Set();
return jobs.filter(j => (j.eventId ? seen.has(j.eventId) : j.createdById === req.user.id));
}
// Normalize job for client UI
function toClient(job) {
@@ -34,7 +50,7 @@ function toClient(job) {
const listScheduledEmails = async (req, res) => {
try {
const { channel } = req.query || {};
const raw = listJobs(channel ? { channel: String(channel) } : {});
const raw = await visibleJobs(req, listJobs(channel ? { channel: String(channel) } : {}));
const filtered = raw
// Provide most-relevant first: queued -> sending -> error -> recent sent
.sort((a, b) => {
@@ -59,7 +75,7 @@ const updateScheduledEmail = async (req, res) => {
try {
const { id } = req.params;
const job = getJob(id);
if (!job) return res.status(404).json({ message: 'Job not found' });
if (!job || !(await visibleJobs(req, [job])).length) return res.status(404).json({ message: 'Job not found' });
if (job.status !== 'queued') return res.status(400).json({ message: 'Only queued jobs can be edited' });
const { scheduledAt, subject, html, text, message } = req.body || {};
@@ -92,7 +108,7 @@ const deleteScheduledEmail = async (req, res) => {
try {
const { id } = req.params;
const job = getJob(id);
if (!job) return res.status(404).json({ message: 'Job not found' });
if (!job || !(await visibleJobs(req, [job])).length) return res.status(404).json({ message: 'Job not found' });
if (job.status !== 'queued') return res.status(400).json({ message: 'Only queued jobs can be deleted' });
const ok = deleteJob(id);
if (!ok) return res.status(404).json({ message: 'Job not found' });
@@ -10,9 +10,8 @@ const getSections = async (req, res) => {
try {
const { eventId } = req.query;
const where = eventId && eventId !== 'all'
? { eventId }
: undefined;
const { withScope, listWhere } = require('../utils/campusScope');
const where = withScope(eventId && eventId !== 'all' ? { eventId } : {}, await listWhere(req, 'event'));
const sections = await prisma.section.findMany({
where,
@@ -2,21 +2,22 @@ const prisma = require('../config/db');
const { safeErrorMessage } = require('../utils/errorUtils');
const { isDonationLeg } = require('../utils/cashupUtils');
const { campusesEnabled, campusWhere, resolveCampusFilter } = require('../utils/campuses');
const { scopeFor, eventWhere: scopeEventWhere, withScope } = require('../utils/campusScope');
// Shared building blocks for the per-dashboard stats endpoints below. Each dashboard
// (staff/supervisor/admin) gets exactly one endpoint that returns only what it renders,
// computed with aggregate queries — never a full payments/events list shipped to the
// client just to be reduced down to a couple of numbers.
async function computeScanStats(userId) {
async function computeScanStats(userId, ticketWhere = {}) {
const startOfDay = new Date();
startOfDay.setHours(0, 0, 0, 0);
const whereBase = { scannedAt: { gte: startOfDay } };
const whereBase = { scannedAt: { gte: startOfDay }, ...ticketWhere };
const [totalToday, myToday, lastHour, byStaffRaw] = await Promise.all([
prisma.ticketUsage.count({ where: whereBase }),
prisma.ticketUsage.count({ where: { ...whereBase, scannedById: userId } }),
prisma.ticketUsage.count({ where: { scannedAt: { gte: new Date(Date.now() - 60 * 60 * 1000) } } }),
prisma.ticketUsage.count({ where: { scannedAt: { gte: new Date(Date.now() - 60 * 60 * 1000) }, ...ticketWhere } }),
prisma.ticketUsage.groupBy({ by: ['scannedById'], where: whereBase, _count: { _all: true } }),
]);
@@ -34,8 +35,9 @@ async function computeScanStats(userId) {
};
}
function getRecentScans(limit = 10) {
function getRecentScans(limit = 10, ticketWhere = {}) {
return prisma.ticketUsage.findMany({
where: ticketWhere,
orderBy: { scannedAt: 'desc' },
take: limit,
select: {
@@ -59,17 +61,20 @@ function getActiveEventsCount(eventWhere = {}) {
}
/**
* `where` pieces for a ?campus= filter (id, slug or 'all'), or nulls for church-wide. A payment
* belongs to a campus through its event, or its registration's event.
* `where` pieces for a ?campus= filter (id, slug or 'all') together with the user's campus scope
* (1.44.0), or empty for church-wide. A payment belongs to a campus through its event, or its
* registration's event — so payments with neither (unlinked donations) aren't counted for a
* scoped user. EXCLUDE_DONATION_LEGS uses NOT, so the payment OR never collides with it.
*/
async function campusFilters(value) {
async function campusFilters(value, scope = null) {
const enabled = await campusesEnabled();
const eventWhere = campusWhere(enabled ? await resolveCampusFilter(value) : '', { enabled });
if (!Object.keys(eventWhere).length) return { eventWhere: {}, byEvent: {}, payment: {} };
const eventWhere = withScope(campusWhere(enabled ? await resolveCampusFilter(value) : '', { enabled }), scopeEventWhere(scope));
if (!Object.keys(eventWhere).length) return { eventWhere: {}, byEvent: {}, payment: {}, usage: {} };
return {
eventWhere,
byEvent: { event: eventWhere },
payment: { OR: [{ event: eventWhere }, { registration: { event: eventWhere } }] },
usage: { ticket: { event: eventWhere } },
};
}
@@ -80,19 +85,19 @@ const EXCLUDE_DONATION_LEGS = {
NOT: { AND: [{ isDonation: false }, { originalPaymentId: { not: null } }, { amount: { gt: 0 } }] },
};
async function computePaymentStats({ includeWeekMonth }) {
async function computePaymentStats({ includeWeekMonth, paymentWhere = {} }) {
const startOfDay = new Date(new Date().setHours(0, 0, 0, 0));
const queries = [
prisma.payment.aggregate({ _sum: { amount: true }, where: { createdAt: { gte: startOfDay }, ...EXCLUDE_DONATION_LEGS } }),
prisma.payment.count({ where: { isDonation: true, createdAt: { gte: startOfDay } } }),
prisma.payment.aggregate({ _sum: { amount: true }, where: { createdAt: { gte: startOfDay }, ...EXCLUDE_DONATION_LEGS, ...paymentWhere } }),
prisma.payment.count({ where: { isDonation: true, createdAt: { gte: startOfDay }, ...paymentWhere } }),
];
if (includeWeekMonth) {
const lastWeek = new Date(startOfDay.getTime() - 7 * 24 * 60 * 60 * 1000);
const lastMonth = new Date(startOfDay.getTime() - 30 * 24 * 60 * 60 * 1000);
queries.push(
prisma.payment.aggregate({ _sum: { amount: true }, where: { createdAt: { gte: lastWeek }, ...EXCLUDE_DONATION_LEGS } }),
prisma.payment.aggregate({ _sum: { amount: true }, where: { createdAt: { gte: lastMonth }, ...EXCLUDE_DONATION_LEGS } }),
prisma.payment.aggregate({ _sum: { amount: true }, where: { createdAt: { gte: lastWeek }, ...EXCLUDE_DONATION_LEGS, ...paymentWhere } }),
prisma.payment.aggregate({ _sum: { amount: true }, where: { createdAt: { gte: lastMonth }, ...EXCLUDE_DONATION_LEGS, ...paymentWhere } }),
);
}
@@ -114,9 +119,10 @@ async function computePaymentStats({ includeWeekMonth }) {
// @access Private/Staff+
const getStaffDashboardStats = async (req, res) => {
try {
const cf = await campusFilters('', await scopeFor(req));
const [scanStats, recentScans] = await Promise.all([
computeScanStats(req.user.id),
getRecentScans(10),
computeScanStats(req.user.id, cf.usage),
getRecentScans(10, cf.usage),
]);
res.json({ scanStats, recentScans });
} catch (error) {
@@ -129,11 +135,12 @@ const getStaffDashboardStats = async (req, res) => {
// @access Private/Supervisor+
const getSupervisorDashboardStats = async (req, res) => {
try {
const cf = await campusFilters('', await scopeFor(req));
const [scanStats, recentScans, paymentStats, activeEventsCount] = await Promise.all([
computeScanStats(req.user.id),
getRecentScans(10),
computePaymentStats({ includeWeekMonth: false }),
getActiveEventsCount(),
computeScanStats(req.user.id, cf.usage),
getRecentScans(10, cf.usage),
computePaymentStats({ includeWeekMonth: false, paymentWhere: cf.payment }),
getActiveEventsCount(cf.eventWhere),
]);
res.json({ scanStats, recentScans, paymentStats, activeEventsCount });
} catch (error) {
@@ -229,7 +236,7 @@ const getOverviewStats = async (req, res) => {
try {
const now = new Date();
const { thisStart, thisEnd, lastStart, lastEnd } = trailingMonthRanges(now);
const cf = await campusFilters(req.query.campus);
const cf = await campusFilters(req.query.campus, await scopeFor(req));
const [thisPayments, lastPayments, thisRegistrations, lastRegistrations, thisTickets, lastTickets, activeEvents] = await Promise.all([
fetchPaymentsWithOriginal({ createdAt: { gte: thisStart, lt: thisEnd }, ...cf.payment }),
@@ -5,18 +5,19 @@ const {
assign, autoAssign, clearAssignments, getSetLists, getMyGroups,
} = require('../controllers/allocationController');
const { protect, staff, supervisor } = require('../middleware/authMiddleware');
const { scopeEvent, campusIndependent } = require('../utils/campusScope');
router.get('/my-groups', protect, staff, getMyGroups);
router.get('/event/:eventId', protect, supervisor, getBoard);
router.post('/sets', protect, supervisor, createSet);
router.put('/sets/:id', protect, supervisor, updateSet);
router.delete('/sets/:id', protect, supervisor, deleteSet);
router.get('/sets/:id/lists', protect, supervisor, getSetLists);
router.post('/sets/:id/groups', protect, supervisor, createGroup);
router.put('/sets/:id/assignments', protect, supervisor, assign);
router.delete('/sets/:id/assignments', protect, supervisor, clearAssignments);
router.post('/sets/:id/auto', protect, supervisor, autoAssign);
router.put('/groups/:id', protect, supervisor, updateGroup);
router.delete('/groups/:id', protect, supervisor, deleteGroup);
router.get('/my-groups', protect, staff, campusIndependent('only the groups the signed-in person leads'), getMyGroups);
router.get('/event/:eventId', protect, supervisor, scopeEvent(), getBoard);
router.post('/sets', protect, supervisor, scopeEvent({ from: req => req.body?.eventId }), createSet);
router.put('/sets/:id', protect, supervisor, scopeEvent({ resolve: 'allocationSet' }), updateSet);
router.delete('/sets/:id', protect, supervisor, scopeEvent({ resolve: 'allocationSet' }), deleteSet);
router.get('/sets/:id/lists', protect, supervisor, scopeEvent({ resolve: 'allocationSet' }), getSetLists);
router.post('/sets/:id/groups', protect, supervisor, scopeEvent({ resolve: 'allocationSet' }), createGroup);
router.put('/sets/:id/assignments', protect, supervisor, scopeEvent({ resolve: 'allocationSet' }), assign);
router.delete('/sets/:id/assignments', protect, supervisor, scopeEvent({ resolve: 'allocationSet' }), clearAssignments);
router.post('/sets/:id/auto', protect, supervisor, scopeEvent({ resolve: 'allocationSet' }), autoAssign);
router.put('/groups/:id', protect, supervisor, scopeEvent({ resolve: 'allocationGroup' }), updateGroup);
router.delete('/groups/:id', protect, supervisor, scopeEvent({ resolve: 'allocationGroup' }), deleteGroup);
module.exports = router;
@@ -3,6 +3,7 @@ const rateLimit = require('express-rate-limit');
const router = express.Router();
const { trackStage, getFunnel } = require('../controllers/analyticsController');
const { protect, supervisor } = require('../middleware/authMiddleware');
const { scopeList } = require('../utils/campusScope');
const trackLimiter = rateLimit({
windowMs: 60 * 1000,
@@ -13,6 +14,6 @@ const trackLimiter = rateLimit({
});
router.post('/track', trackLimiter, trackStage);
router.get('/funnel', protect, supervisor, getFunnel);
router.get('/funnel', protect, supervisor, scopeList, getFunnel);
module.exports = router;
@@ -6,20 +6,21 @@ const {
myCertificates, downloadCertificate, verifyCertificate,
} = require('../controllers/attendanceController');
const { protect, staff, supervisor } = require('../middleware/authMiddleware');
const { scopeEvent, campusIndependent } = require('../utils/campusScope');
// Certificates — fixed paths first so they aren't taken as an :eventId
router.get('/certificates/verify/:code', verifyCertificate);
router.get('/certificates/mine', protect, myCertificates);
router.post('/certificates/preview', protect, supervisor, previewCertificate);
router.post('/certificates/preview', protect, supervisor, campusIndependent('previews a certificate template from the request body'), previewCertificate);
router.get('/certificates/:id/pdf', protect, downloadCertificate);
router.post('/certificates/:id/revoke', protect, supervisor, revokeCertificate);
router.post('/certificates/:id/revoke', protect, supervisor, scopeEvent({ resolve: 'certificate' }), revokeCertificate);
// Attendance register
router.get('/:eventId', protect, staff, getRegister);
router.get('/:eventId/export', protect, staff, exportRegister);
router.post('/:eventId/mark', protect, supervisor, markAttendance);
router.post('/:eventId/certificates', protect, supervisor, issueCertificates);
router.post('/:eventId/certificates/send', protect, supervisor, sendCertificatesHandler);
router.get('/:eventId/certificates.pdf', protect, supervisor, downloadEventCertificates);
router.get('/:eventId', protect, staff, scopeEvent(), getRegister);
router.get('/:eventId/export', protect, staff, scopeEvent(), exportRegister);
router.post('/:eventId/mark', protect, supervisor, scopeEvent(), markAttendance);
router.post('/:eventId/certificates', protect, supervisor, scopeEvent(), issueCertificates);
router.post('/:eventId/certificates/send', protect, supervisor, scopeEvent(), sendCertificatesHandler);
router.get('/:eventId/certificates.pdf', protect, supervisor, scopeEvent(), downloadEventCertificates);
module.exports = router;
@@ -2,8 +2,9 @@ const express = require('express');
const router = express.Router();
const { scheduleAutomations } = require('../controllers/automationController');
const { protect, supervisor } = require('../middleware/authMiddleware');
const { scopeEvent } = require('../utils/campusScope');
// Schedule multiple automation emails for an event
router.post('/schedule', protect, supervisor, scheduleAutomations);
router.post('/schedule', protect, supervisor, scopeEvent({ from: req => req.body?.eventId }), scheduleAutomations);
module.exports = router;
@@ -2,8 +2,9 @@ const express = require('express');
const router = express.Router();
const { getBanner, setBanner } = require('../controllers/bannerController');
const { protect, supervisor } = require('../middleware/authMiddleware');
const { unscopedOnly } = require('../utils/campusScope');
router.get('/', getBanner);
router.post('/', protect, supervisor, setBanner);
router.post('/', protect, supervisor, unscopedOnly, setBanner);
module.exports = router;
@@ -2,10 +2,11 @@ const express = require('express');
const router = express.Router();
const { previewBroadcast, sendBroadcast, scheduleBroadcast } = require('../controllers/broadcastController');
const { protect, supervisor } = require('../middleware/authMiddleware');
const { scopeBroadcast } = require('../utils/campusScope');
// All routes require supervisor (or admin via middleware logic) access
router.post('/preview', protect, supervisor, previewBroadcast);
router.post('/send', protect, supervisor, sendBroadcast);
router.post('/schedule', protect, supervisor, scheduleBroadcast);
router.post('/preview', protect, supervisor, scopeBroadcast({ freeformField: 'emails' }), previewBroadcast);
router.post('/send', protect, supervisor, scopeBroadcast({ freeformField: 'emails' }), sendBroadcast);
router.post('/schedule', protect, supervisor, scopeBroadcast({ freeformField: 'emails' }), scheduleBroadcast);
module.exports = router;
@@ -2,13 +2,14 @@ const express = require('express');
const router = express.Router();
const { listBundles, createBundle, updateBundle, deleteBundle, quoteBundles } = require('../controllers/bundleController');
const { protect, supervisor, optionalAuth } = require('../middleware/authMiddleware');
const { scopeEvent } = require('../utils/campusScope');
// What a basket gets off before registering (guests included)
router.post('/quote', optionalAuth, quoteBundles);
router.get('/event/:eventId', protect, supervisor, listBundles);
router.post('/event/:eventId', protect, supervisor, createBundle);
router.put('/:id', protect, supervisor, updateBundle);
router.delete('/:id', protect, supervisor, deleteBundle);
router.get('/event/:eventId', protect, supervisor, scopeEvent(), listBundles);
router.post('/event/:eventId', protect, supervisor, scopeEvent({ need: 'manage' }), createBundle);
router.put('/:id', protect, supervisor, scopeEvent({ resolve: 'bundle', need: 'manage' }), updateBundle);
router.delete('/:id', protect, supervisor, scopeEvent({ resolve: 'bundle', need: 'manage' }), deleteBundle);
module.exports = router;
@@ -5,6 +5,7 @@ const {
getCampusAudience,
} = require('../controllers/campusController');
const { protect, admin, supervisor } = require('../middleware/authMiddleware');
const { scopeList } = require('../utils/campusScope');
// Multi-campus (utils/campuses.js). The public list is empty while campuses are off.
router.get('/', getCampuses);
@@ -15,6 +16,6 @@ router.put('/order', protect, admin, reorderCampuses);
router.post('/', protect, admin, createCampus);
router.put('/:id', protect, admin, updateCampus);
router.delete('/:id', protect, admin, deleteCampus);
router.get('/:id/audience', protect, supervisor, getCampusAudience);
router.get('/:id/audience', protect, supervisor, scopeList, getCampusAudience);
module.exports = router;
@@ -2,11 +2,12 @@ const express = require('express');
const router = express.Router();
const { getEventCashup, getCashByRecordedUser, savePersonCash, saveEventCashupDraft, closeEvent, reopenEvent, resolvePending, getCashupAudit } = require('../controllers/cashupController');
const { protect, supervisor, admin } = require('../middleware/authMiddleware');
const { scopeEvent, scopeList } = require('../utils/campusScope');
router.get('/audit', protect, supervisor, getCashupAudit);
router.get('/event/:eventId', protect, supervisor, getEventCashup);
router.get('/event/:eventId/cash-by-user', protect, supervisor, getCashByRecordedUser);
router.put('/event/:eventId/person-cash/:userId', protect, supervisor, savePersonCash);
router.get('/audit', protect, supervisor, scopeList, getCashupAudit);
router.get('/event/:eventId', protect, supervisor, scopeEvent({ need: 'manage' }), getEventCashup);
router.get('/event/:eventId/cash-by-user', protect, supervisor, scopeEvent({ need: 'manage' }), getCashByRecordedUser);
router.put('/event/:eventId/person-cash/:userId', protect, supervisor, scopeEvent({ need: 'manage' }), savePersonCash);
router.put('/event/:eventId/draft', protect, admin, saveEventCashupDraft);
router.post('/event/:eventId/close', protect, admin, closeEvent);
router.post('/event/:eventId/reopen', protect, admin, reopenEvent);
@@ -3,14 +3,15 @@ const rateLimit = require('express-rate-limit');
const router = express.Router();
const { getConsent, answerConsent, listEventConsent, resendRequest, resendPending, rerequestConsent, medicalList } = require('../controllers/consentController');
const { protect, staff, supervisor } = require('../middleware/authMiddleware');
const { scopeEvent } = require('../utils/campusScope');
// The token in the link is the parent's only credential, so keep guessing slow.
const consentLimiter = rateLimit({ windowMs: 60 * 1000, max: 30, message: { message: 'Too many attempts. Please try again in a minute.' } });
router.get('/events/:eventId', protect, staff, listEventConsent);
router.post('/events/:eventId/resend-pending', protect, supervisor, resendPending);
router.post('/events/:eventId/rerequest', protect, supervisor, rerequestConsent);
router.get('/events/:eventId/medical', protect, supervisor, medicalList);
router.get('/events/:eventId', protect, staff, scopeEvent(), listEventConsent);
router.post('/events/:eventId/resend-pending', protect, supervisor, scopeEvent(), resendPending);
router.post('/events/:eventId/rerequest', protect, supervisor, scopeEvent(), rerequestConsent);
router.get('/events/:eventId/medical', protect, supervisor, scopeEvent(), medicalList);
router.post('/requests/:id/resend', protect, resendRequest);
// Public consent page
+2 -1
View File
@@ -2,9 +2,10 @@ const express = require('express');
const router = express.Router();
const { getEventCosts, createEventCost, updateEventCost, deleteEventCost } = require('../controllers/costController');
const { protect, supervisor, admin } = require('../middleware/authMiddleware');
const { scopeEvent } = require('../utils/campusScope');
// Mounted at /api — paths below match the documented /api/events/:eventId/costs and /api/costs/:id shape
router.get('/events/:eventId/costs', protect, supervisor, getEventCosts);
router.get('/events/:eventId/costs', protect, supervisor, scopeEvent({ need: 'manage' }), getEventCosts);
router.post('/events/:eventId/costs', protect, admin, createEventCost);
router.put('/costs/:id', protect, admin, updateEventCost);
router.delete('/costs/:id', protect, admin, deleteEventCost);
@@ -2,14 +2,15 @@ const express = require('express');
const router = express.Router();
const { listCoupons, getCoupon, createCoupon, updateCoupon, validateCode, listRedemptions } = require('../controllers/couponController');
const { protect, supervisor, optionalAuth } = require('../middleware/authMiddleware');
const { scopeList } = require('../utils/campusScope');
// Check a code against a basket before registering (guests included)
router.post('/validate', optionalAuth, validateCode);
router.get('/', protect, supervisor, listCoupons);
router.post('/', protect, supervisor, createCoupon);
router.get('/redemptions', protect, supervisor, listRedemptions);
router.get('/:id', protect, supervisor, getCoupon);
router.put('/:id', protect, supervisor, updateCoupon);
router.get('/', protect, supervisor, scopeList, listCoupons);
router.post('/', protect, supervisor, scopeList, createCoupon);
router.get('/redemptions', protect, supervisor, scopeList, listRedemptions);
router.get('/:id', protect, supervisor, scopeList, getCoupon);
router.put('/:id', protect, supervisor, scopeList, updateCoupon);
module.exports = router;
@@ -2,13 +2,14 @@ const express = require('express');
const router = express.Router();
const { getEventFeedback, saveEventFeedback, deleteEventFeedback, sendNow, getPublicForm, submitPublicForm, getSummary } = require('../controllers/feedbackController');
const { protect, supervisor } = require('../middleware/authMiddleware');
const { scopeEvent, scopeList } = require('../utils/campusScope');
router.get('/public/:token', getPublicForm);
router.post('/public/:token', submitPublicForm);
router.get('/summary', protect, supervisor, getSummary);
router.get('/event/:eventId', protect, supervisor, getEventFeedback);
router.put('/event/:eventId', protect, supervisor, saveEventFeedback);
router.delete('/event/:eventId', protect, supervisor, deleteEventFeedback);
router.post('/event/:eventId/send-now', protect, supervisor, sendNow);
router.get('/summary', protect, supervisor, scopeList, getSummary);
router.get('/event/:eventId', protect, supervisor, scopeEvent(), getEventFeedback);
router.put('/event/:eventId', protect, supervisor, scopeEvent({ need: 'manage' }), saveEventFeedback);
router.delete('/event/:eventId', protect, supervisor, scopeEvent({ need: 'manage' }), deleteEventFeedback);
router.post('/event/:eventId/send-now', protect, supervisor, scopeEvent({ need: 'manage' }), sendNow);
module.exports = router;
+2 -1
View File
@@ -2,8 +2,9 @@ const express = require('express');
const router = express.Router();
const { listFormResponses } = require('../controllers/formController');
const { protect, staff } = require('../middleware/authMiddleware');
const { scopeList } = require('../utils/campusScope');
// Staff or higher can view submitted forms
router.get('/responses', protect, staff, listFormResponses);
router.get('/responses', protect, staff, scopeList, listFormResponses);
module.exports = router;
@@ -2,19 +2,20 @@ const express = require('express');
const router = express.Router();
const { getAllProviderTransactions, getUnreconciledProviderTransactions, reconcileProviderTransaction, ignoreProviderTransaction } = require('../controllers/providerTransactionsController');
const { protect, supervisor} = require('../middleware/authMiddleware');
const { unscopedOnly } = require('../utils/campusScope');
// Mounted at /api/provider-transactions (and /api/yoco-transactions, the older name).
// GET all payment provider transactions (admin/supervisor)
router.get('/', protect, supervisor, getAllProviderTransactions);
router.get('/', protect, supervisor, unscopedOnly, getAllProviderTransactions);
// GET all unreconciled transactions (admin/supervisor)
router.get('/unreconciled', protect, supervisor, getUnreconciledProviderTransactions);
router.get('/unreconciled', protect, supervisor, unscopedOnly, getUnreconciledProviderTransactions);
// POST reconcile a transaction
router.post('/:id/reconcile', protect, supervisor, reconcileProviderTransaction);
router.post('/:id/reconcile', protect, supervisor, unscopedOnly, reconcileProviderTransaction);
// POST ignore a transaction
router.post('/:id/ignore', protect, supervisor, ignoreProviderTransaction);
router.post('/:id/ignore', protect, supervisor, unscopedOnly, ignoreProviderTransaction);
module.exports = router;
@@ -2,10 +2,11 @@ const express = require('express');
const router = express.Router();
const { listScheduledEmails, updateScheduledEmail, deleteScheduledEmail } = require('../controllers/scheduledEmailsController');
const { protect, supervisor } = require('../middleware/authMiddleware');
const { scopeList } = require('../utils/campusScope');
// All routes require supervisor (or admin via middleware logic) access
router.get('/', protect, supervisor, listScheduledEmails);
router.patch('/:id', protect, supervisor, updateScheduledEmail);
router.delete('/:id', protect, supervisor, deleteScheduledEmail);
router.get('/', protect, supervisor, scopeList, listScheduledEmails);
router.patch('/:id', protect, supervisor, scopeList, updateScheduledEmail);
router.delete('/:id', protect, supervisor, scopeList, deleteScheduledEmail);
module.exports = router;
@@ -7,10 +7,11 @@ const {
updateSection
} = require('../controllers/sectionController');
const { protect, admin, supervisor, staff } = require('../middleware/authMiddleware');
const { scopeEvent, scopeList } = require('../utils/campusScope');
router.get('/', protect, staff, getSections);
router.post('/', protect, supervisor, createSection);
router.get('/', protect, staff, scopeList, getSections);
router.post('/', protect, supervisor, scopeEvent({ from: req => req.body?.eventId, need: 'manage' }), createSection);
router.delete('/:id', protect, admin, deleteSection);
router.put('/:id', protect, supervisor, updateSection);
router.put('/:id', protect, supervisor, scopeEvent({ resolve: 'section', need: 'manage' }), updateSection);
module.exports = router;
@@ -2,9 +2,10 @@ const express = require('express');
const router = express.Router();
const { getEventSponsorship, createSponsorCheckout, getPool } = require('../controllers/sponsorshipController');
const { protect, supervisor, optionalAuth } = require('../middleware/authMiddleware');
const { scopeEvent } = require('../utils/campusScope');
router.get('/event/:eventId', getEventSponsorship);
router.get('/event/:eventId/pool', protect, supervisor, getPool);
router.get('/event/:eventId/pool', protect, supervisor, scopeEvent(), getPool);
router.post('/checkout', optionalAuth, createSponsorCheckout);
module.exports = router;
@@ -2,16 +2,17 @@ const express = require('express');
const router = express.Router();
const { getStaffDashboardStats, getSupervisorDashboardStats, getAdminDashboardStats, getOverviewStats } = require('../controllers/statsController');
const { protect, staff, supervisor, admin } = require('../middleware/authMiddleware');
const { scopeList } = require('../utils/campusScope');
// One endpoint per dashboard — each returns exactly what that dashboard renders in a
// single response instead of the dashboard making several separate calls (and, previously,
// pulling full payments/events lists just to reduce them to a couple of numbers).
router.get('/staff', protect, staff, getStaffDashboardStats);
router.get('/supervisor', protect, supervisor, getSupervisorDashboardStats);
router.get('/staff', protect, staff, scopeList, getStaffDashboardStats);
router.get('/supervisor', protect, supervisor, scopeList, getSupervisorDashboardStats);
router.get('/admin', protect, admin, getAdminDashboardStats);
// Month-over-month KPIs + trend + top events, shared by the Admin and Supervisor dashboards.
// Staff never sees financial data, so this has no staff-accessible route.
router.get('/overview', protect, supervisor, getOverviewStats);
router.get('/overview', protect, supervisor, scopeList, getOverviewStats);
module.exports = router;
@@ -3,12 +3,13 @@ const router = express.Router();
const { upload, uploadEventImage, uploadLogo, uploadLogoImage, uploadFavicon, uploadFaviconImage } = require('../controllers/uploadController');
const { protect, supervisor, admin } = require('../middleware/authMiddleware');
const { campusIndependent } = require('../utils/campusScope');
const prisma = require('../config/db');
// @route POST /api/uploads/event-image
// @desc Upload an image for an event
// @access Private (Supervisor+ recommended)
router.post('/event-image', protect, supervisor, (req, res, next) => {
router.post('/event-image', protect, supervisor, campusIndependent('stores an image file; the event it goes on is checked when the event is saved'), (req, res, next) => {
upload.single('image')(req, res, (err) => {
if (err) {
req.multerError = err;
+3 -2
View File
@@ -26,6 +26,7 @@ const {
getMyActivity,
} = require('../controllers/userController');
const { protect, admin, supervisor, loginLimiter} = require('../middleware/authMiddleware');
const { campusIndependent } = require('../utils/campusScope');
// Public routes
router.post('/', registerUser);
@@ -51,9 +52,9 @@ router.post('/2fa/disable', protect, loginLimiter, disableTwoFactor);
// Admin routes
router.route('/')
.get(protect, supervisor, getUsers);
.get(protect, supervisor, campusIndependent('accounts are shared across campuses'), getUsers);
router.get('/check-exists', protect, supervisor, checkUserExists);
router.get('/check-exists', protect, supervisor, campusIndependent('accounts are shared across campuses'), checkUserExists);
router.route('/:id')
.get(protect, admin, getUserById)
@@ -3,6 +3,7 @@ const rateLimit = require('express-rate-limit');
const router = express.Router();
const { joinWaitlist, myWaitlist, leaveWaitlist, claimInfo, eventWaitlist, offerManually, moveEntry, removeEntry } = require('../controllers/waitlistController');
const { protect, staff, supervisor, optionalAuth } = require('../middleware/authMiddleware');
const { scopeEvent } = require('../utils/campusScope');
// Claim links are credentials, so keep guessing slow.
const claimLimiter = rateLimit({ windowMs: 60 * 1000, max: 30, message: { message: 'Too many attempts. Please try again in a minute.' } });
@@ -10,10 +11,10 @@ const claimLimiter = rateLimit({ windowMs: 60 * 1000, max: 30, message: { messag
router.post('/', optionalAuth, joinWaitlist);
router.get('/mine', protect, myWaitlist);
router.get('/claim/:token', claimLimiter, claimInfo);
router.get('/events/:eventId', protect, staff, eventWaitlist);
router.post('/:id/offer', protect, supervisor, offerManually);
router.post('/:id/move', protect, supervisor, moveEntry);
router.post('/:id/remove', protect, supervisor, removeEntry);
router.get('/events/:eventId', protect, staff, scopeEvent(), eventWaitlist);
router.post('/:id/offer', protect, supervisor, scopeEvent({ resolve: 'waitlistEntry' }), offerManually);
router.post('/:id/move', protect, supervisor, scopeEvent({ resolve: 'waitlistEntry' }), moveEntry);
router.post('/:id/remove', protect, supervisor, scopeEvent({ resolve: 'waitlistEntry' }), removeEntry);
router.delete('/:id', protect, leaveWaitlist);
module.exports = router;
@@ -2,9 +2,10 @@ const express = require('express');
const router = express.Router();
const { previewWhatsAppBroadcast, sendWhatsAppBroadcast, scheduleWhatsAppBroadcast } = require('../controllers/whatsappBroadcastController');
const { protect, supervisor } = require('../middleware/authMiddleware');
const { scopeBroadcast } = require('../utils/campusScope');
router.post('/preview', protect, supervisor, previewWhatsAppBroadcast);
router.post('/send', protect, supervisor, sendWhatsAppBroadcast);
router.post('/schedule', protect, supervisor, scheduleWhatsAppBroadcast);
router.post('/preview', protect, supervisor, scopeBroadcast({ freeformField: 'phones' }), previewWhatsAppBroadcast);
router.post('/send', protect, supervisor, scopeBroadcast({ freeformField: 'phones' }), sendWhatsAppBroadcast);
router.post('/schedule', protect, supervisor, scopeBroadcast({ freeformField: 'phones' }), scheduleWhatsAppBroadcast);
module.exports = router;
@@ -0,0 +1,231 @@
/**
* Campus-scoped staff (1.44.0). A supervisor or staff member can be limited to some campuses
* (Admin → Users → "Limit to campuses"). They then see their campuses' events plus events for
* all campuses (Event.campusId null) — and can work on those church-wide events (view, scan,
* door payments, manual registrations) but not set them up, cash them up or refund them.
*
* Unscoped (no limits) = everything, as before. Admins are never scoped, and scopes are ignored
* while campuses are off (Site settings → Campuses).
*
* How a route is checked — every staff/supervisor route carries one of these markers, and
* tests/campusScopeRoutes.test.js fails on any route that doesn't:
* scopeEvent({ resolve, from, need }) the route works on one event (or a record of one)
* scopeList the controller filters its list with listWhere()
* unscopedOnly admins and unscoped supervisors only
* campusIndependent('reason') nothing to do with any event's campus
*/
const prisma = require('../config/db');
const { campusesEnabled } = require('./campuses');
const STAFF_ROLES = new Set(['supervisor', 'staff']);
/**
* The scope of the signed-in user: null (unscoped) or { campusIds, names }. Worked out once
* per request.
*/
async function scopeFor(req) {
if (req._campusScope !== undefined) return req._campusScope;
let scope = null;
if (req.user && STAFF_ROLES.has(req.user.role) && await campusesEnabled()) {
const row = await prisma.user.findUnique({ where: { id: req.user.id }, select: { scopedCampuses: { select: { id: true, name: true } } } });
const campuses = row?.scopedCampuses || [];
if (campuses.length) scope = { campusIds: campuses.map(c => c.id), names: campuses.map(c => c.name) };
}
req._campusScope = scope;
return scope;
}
/** The `where` on events for a scope: its campuses plus church-wide events. {} when unscoped. */
function eventWhere(scope) {
if (!scope) return {};
return { OR: [{ campusId: { in: scope.campusIds } }, { campusId: null }] };
}
/** The `where` on events a scope may manage: only its campuses' (not church-wide). {} when unscoped. */
function manageWhere(scope) {
if (!scope) return {};
return { campusId: { in: scope.campusIds } };
}
/**
* The same, through a relation path: relWhere(scope, 'event') → { event: {...} },
* relWhere(scope, 'registration.event') → { registration: { event: {...} } }.
*/
function relWhere(scope, path) {
if (!scope) return {};
return path.split('.').reverse().reduce((inner, key) => ({ [key]: inner }), eventWhere(scope));
}
/** Can this scope see/work on an event at `campusId` (null = all campuses)? */
function canView(scope, campusId) {
return !scope || campusId == null || scope.campusIds.includes(campusId);
}
/** Can this scope set up, cash up or refund an event at `campusId`? Not church-wide ones. */
function canManage(scope, campusId) {
return !scope || (campusId != null && scope.campusIds.includes(campusId));
}
// id → { id, campusId, campusName } of the event a record belongs to, or null if there's no such
// record. The event select is shared so every resolver answers the same shape.
const EV = { select: { id: true, campusId: true, campus: { select: { name: true } } } };
const shape = ev => (ev ? { id: ev.id, campusId: ev.campusId, campusName: ev.campus?.name || null } : null);
const RESOLVERS = {
event: async id => shape(await prisma.event.findUnique({ where: { id }, ...EV })),
registration: async id => shape((await prisma.registration.findUnique({ where: { id }, select: { event: EV } }))?.event),
ticket: async id => shape((await prisma.ticket.findUnique({ where: { id }, select: { event: EV } }))?.event),
ticketQr: async qrCode => shape((await prisma.ticket.findUnique({ where: { qrCode }, select: { event: EV } }))?.event),
payment: async id => {
const p = await prisma.payment.findUnique({ where: { id }, select: { event: EV, registration: { select: { event: EV } } } });
return shape(p?.event || p?.registration?.event);
},
eventOption: async id => shape((await prisma.eventOption.findUnique({ where: { id }, select: { event: EV } }))?.event),
optionVariant: async id => shape((await prisma.optionVariant.findUnique({ where: { id }, select: { eventOption: { select: { event: EV } } } }))?.eventOption?.event),
bundle: async id => shape((await prisma.eventBundle.findUnique({ where: { id }, select: { event: EV } }))?.event),
allocationSet: async id => shape((await prisma.allocationSet.findUnique({ where: { id }, select: { event: EV } }))?.event),
allocationGroup: async id => shape((await prisma.allocationGroup.findUnique({ where: { id }, select: { set: { select: { event: EV } } } }))?.set?.event),
waitlistEntry: async id => shape((await prisma.waitlistEntry.findUnique({ where: { id }, select: { event: EV } }))?.event),
scanLock: async id => shape((await prisma.scanLock.findUnique({ where: { id }, select: { event: EV } }))?.event),
syncReport: async id => shape((await prisma.offlineSyncReport.findUnique({ where: { id }, select: { scanLock: { select: { event: EV } } } }))?.scanLock?.event),
section: async id => shape((await prisma.section.findUnique({ where: { id }, select: { event: EV } }))?.event),
certificate: async id => shape((await prisma.certificate.findUnique({ where: { id }, select: { event: EV } }))?.event),
};
/** The event a record belongs to (see RESOLVERS), or null. */
async function eventOf(kind, id) {
const resolve = RESOLVERS[kind];
if (!resolve) throw new Error(`No campus resolver for "${kind}"`);
if (!id) return null;
return resolve(String(id));
}
const NOT_FOUND = { message: 'Not found' };
const CHURCH_WIDE_MSG = 'This is an event for all campuses — only admins and supervisors for every campus can change it.';
/**
* Check a scoped user against one event, found from the request. Out of scope → 404 (another
* campus's records don't leak); a church-wide event when `need: 'manage'` → 403. Records that
* don't exist pass through so the controller answers as it always has.
* resolve which RESOLVERS entry turns the id into its event (default 'event')
* from req → id (default req.params.eventId || req.params.id)
* need 'view' (default) or 'manage'
*/
function scopeEvent({ resolve = 'event', from = req => req.params.eventId || req.params.id, need = 'view' } = {}) {
if (!RESOLVERS[resolve]) throw new Error(`No campus resolver for "${resolve}"`);
const mw = async (req, res, next) => {
try {
const scope = await scopeFor(req);
if (!scope) return next();
const ev = await eventOf(resolve, from(req));
if (!ev) return next();
if (!canView(scope, ev.campusId)) return res.status(404).json(NOT_FOUND);
if (need === 'manage' && !canManage(scope, ev.campusId)) return res.status(403).json({ code: 'CHURCH_WIDE_EVENT', message: CHURCH_WIDE_MSG });
req.scopedEvent = ev;
return next();
} catch (e) {
return next(e);
}
};
mw.campusScope = `event:${resolve}:${need}`;
return mw;
}
/** Marker: the controller filters what it lists with listWhere(). */
const scopeList = (req, res, next) => next();
scopeList.campusScope = 'list';
/** Admins and unscoped supervisors/staff only. */
const unscopedOnly = async (req, res, next) => {
try {
if (await scopeFor(req)) return res.status(403).json({ code: 'CAMPUS_SCOPED', message: 'Only admins and supervisors for every campus can do this.' });
return next();
} catch (e) {
return next(e);
}
};
unscopedOnly.campusScope = 'unscoped-only';
/** Marker for a route that has nothing to do with any event's campus; the reason is required. */
function campusIndependent(reason) {
if (!reason) throw new Error('campusIndependent needs a reason');
const mw = (req, res, next) => next();
mw.campusScope = `independent: ${reason}`;
return mw;
}
/**
* Combine a controller's `where` with a scope `where` without either overwriting the other's
* OR/AND (spreading would): { AND: [where, extra] }, or `where` itself when there's no scope.
*/
function withScope(where, extra) {
if (!extra || !Object.keys(extra).length) return where;
if (!where || !Object.keys(where).length) return extra;
return { AND: [where, extra] };
}
/**
* Broadcasts (email/WhatsApp, send/preview/schedule): a scoped supervisor may only message
* people at their campuses (home campus) or attendees of events they can see, and can't add
* free-typed addresses (`freeformField`: 'emails' or 'phones'). The placeholder event must be
* one they can see.
*/
function scopeBroadcast({ freeformField }) {
const mw = async (req, res, next) => {
try {
const scope = await scopeFor(req);
if (!scope) return next();
const body = req.body || {};
if (String(body[freeformField] || '').trim()) {
return res.status(403).json({ code: 'CAMPUS_SCOPED', message: 'Supervisors for some campuses can only message people from the list, not typed-in addresses.' });
}
if (body.eventId) {
const ev = await eventOf('event', body.eventId);
if (ev && !canView(scope, ev.campusId)) return res.status(404).json(NOT_FOUND);
}
const ids = Array.isArray(body.userIds) ? [...new Set(body.userIds.filter(x => typeof x === 'string' && x))] : [];
if (ids.length) {
const allowed = await prisma.user.count({
where: {
id: { in: ids },
OR: [
{ homeCampusId: { in: scope.campusIds } },
{ registrations: { some: { event: eventWhere(scope) } } },
],
},
});
if (allowed !== ids.length) {
const n = ids.length - allowed;
return res.status(403).json({ code: 'CAMPUS_SCOPED', message: `${n} of the people selected ${n === 1 ? "isn't" : "aren't"} at your campuses or registered for your events.` });
}
}
return next();
} catch (e) {
return next(e);
}
};
mw.campusScope = 'broadcast';
return mw;
}
/**
* Coupons: a scoped supervisor may see and change a coupon only when it's limited to events,
* all at their campuses (a coupon for every event, or a church-wide event, is unscoped-only).
* `campusIds` are the campuses of the coupon's events.
*/
function couponAllowed(scope, campusIds) {
if (!scope) return true;
return campusIds.length > 0 && campusIds.every(id => id != null && scope.campusIds.includes(id));
}
/** The `where` for a list endpoint: relWhere through `path` ('' = the event itself). */
async function listWhere(req, path = '') {
const scope = await scopeFor(req);
return path ? relWhere(scope, path) : eventWhere(scope);
}
module.exports = {
scopeFor, eventWhere, manageWhere, relWhere, canView, canManage, eventOf, RESOLVERS,
scopeEvent, scopeList, unscopedOnly, campusIndependent, scopeBroadcast, couponAllowed, listWhere, withScope, CHURCH_WIDE_MSG,
};
@@ -0,0 +1,47 @@
// Every staff/supervisor route must say how it handles campus-scoped staff (utils/campusScope.js):
// scopeEvent(...), scopeList, unscopedOnly or campusIndependent('reason'). A route that says
// nothing would show a campus-limited supervisor every campus's data, so this fails on it.
const fs = require('fs');
const path = require('path');
const { staff, supervisor } = require('../src/middleware/authMiddleware');
const ROUTES_DIR = path.join(__dirname, '..', 'src', 'routes');
function staffRoutes() {
const out = [];
for (const file of fs.readdirSync(ROUTES_DIR).filter(f => f.endsWith('.js'))) {
const router = require(path.join(ROUTES_DIR, file));
for (const layer of router.stack || []) {
if (!layer.route) continue;
const handles = layer.route.stack.map(s => s.handle);
const role = handles.includes(staff) || handles.includes(supervisor);
if (!role) continue;
for (const method of Object.keys(layer.route.methods)) {
// router.route('/x').get(...).put(...) puts every method's handlers on one route.
const forMethod = layer.route.stack.filter(s => s.method === method || s.method === undefined).map(s => s.handle);
const marker = forMethod.find(h => h && h.campusScope);
out.push({ file, method: method.toUpperCase(), path: layer.route.path, marker: marker ? marker.campusScope : null });
}
}
}
return out;
}
describe('campus scope on staff and supervisor routes', () => {
const routes = staffRoutes();
test('finds the staff and supervisor routes', () => {
expect(routes.length).toBeGreaterThan(100);
});
test('every one says how it handles campus-scoped staff', () => {
const missing = routes.filter(r => !r.marker).map(r => `${r.file} ${r.method} ${r.path}`);
expect(missing).toEqual([]);
});
test('a campus-independent route gives a reason', () => {
for (const r of routes.filter(x => x.marker && x.marker.startsWith('independent'))) {
expect(r.marker.length).toBeGreaterThan('independent: '.length + 5);
}
});
});