Krow-workspace/backend/query-api/src/routes/mobile.js

import { Router } from 'express';
import { requireAuth, requirePolicy } from '../middleware/auth.js';
import {
  getClientDashboard,
  getClientSession,
  getCoverageStats,
  getCurrentAttendanceStatus,
  getCurrentBill,
  getPaymentChart,
  getPaymentsSummary,
  getPersonalInfo,
  getProfileSectionsStatus,
  getSavings,
  getStaffDashboard,
  getStaffProfileCompletion,
  getStaffSession,
  getStaffShiftDetail,
  listAssignedShifts,
  listBusinessAccounts,
  listCancelledShifts,
  listCertificates,
  listCostCenters,
  listCoverageByDate,
  listCompletedShifts,
  listHubManagers,
  listHubs,
  listIndustries,
  listInvoiceHistory,
  listOpenShifts,
  listOrderItemsByDateRange,
  listPaymentsHistory,
  listPendingAssignments,
  listPendingInvoices,
  listProfileDocuments,
  listRecentReorders,
  listSkills,
  listStaffAvailability,
  listStaffBankAccounts,
  listStaffBenefits,
  listTodayShifts,
  listVendorRoles,
  listVendors,
  getSpendBreakdown,
} from '../services/mobile-query-service.js';

const defaultQueryService = {
  getClientDashboard,
  getClientSession,
  getCoverageStats,
  getCurrentAttendanceStatus,
  getCurrentBill,
  getPaymentChart,
  getPaymentsSummary,
  getPersonalInfo,
  getProfileSectionsStatus,
  getSavings,
  getSpendBreakdown,
  getStaffDashboard,
  getStaffProfileCompletion,
  getStaffSession,
  getStaffShiftDetail,
  listAssignedShifts,
  listBusinessAccounts,
  listCancelledShifts,
  listCertificates,
  listCostCenters,
  listCoverageByDate,
  listCompletedShifts,
  listHubManagers,
  listHubs,
  listIndustries,
  listInvoiceHistory,
  listOpenShifts,
  listOrderItemsByDateRange,
  listPaymentsHistory,
  listPendingAssignments,
  listPendingInvoices,
  listProfileDocuments,
  listRecentReorders,
  listSkills,
  listStaffAvailability,
  listStaffBankAccounts,
  listStaffBenefits,
  listTodayShifts,
  listVendorRoles,
  listVendors,
};

function requireQueryParam(name, value) {
  if (!value) {
    const error = new Error(`${name} is required`);
    error.code = 'VALIDATION_ERROR';
    error.status = 400;
    error.details = { field: name };
    throw error;
  }
  return value;
}

export function createMobileQueryRouter(queryService = defaultQueryService) {
  const router = Router();

  router.get('/client/session', requireAuth, requirePolicy('client.session.read', 'session'), async (req, res, next) => {
    try {
      const data = await queryService.getClientSession(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/dashboard', requireAuth, requirePolicy('client.dashboard.read', 'dashboard'), async (req, res, next) => {
    try {
      const data = await queryService.getClientDashboard(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/reorders', requireAuth, requirePolicy('orders.reorder.read', 'order'), async (req, res, next) => {
    try {
      const items = await queryService.listRecentReorders(req.actor.uid, req.query.limit);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/billing/accounts', requireAuth, requirePolicy('billing.accounts.read', 'billing'), async (req, res, next) => {
    try {
      const items = await queryService.listBusinessAccounts(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/billing/invoices/pending', requireAuth, requirePolicy('billing.invoices.read', 'billing'), async (req, res, next) => {
    try {
      const items = await queryService.listPendingInvoices(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/billing/invoices/history', requireAuth, requirePolicy('billing.invoices.read', 'billing'), async (req, res, next) => {
    try {
      const items = await queryService.listInvoiceHistory(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/billing/current-bill', requireAuth, requirePolicy('billing.summary.read', 'billing'), async (req, res, next) => {
    try {
      const data = await queryService.getCurrentBill(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/billing/savings', requireAuth, requirePolicy('billing.summary.read', 'billing'), async (req, res, next) => {
    try {
      const data = await queryService.getSavings(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/billing/spend-breakdown', requireAuth, requirePolicy('billing.summary.read', 'billing'), async (req, res, next) => {
    try {
      const items = await queryService.getSpendBreakdown(req.actor.uid, req.query);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/coverage', requireAuth, requirePolicy('coverage.read', 'coverage'), async (req, res, next) => {
    try {
      const items = await queryService.listCoverageByDate(req.actor.uid, { date: requireQueryParam('date', req.query.date) });
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/coverage/stats', requireAuth, requirePolicy('coverage.read', 'coverage'), async (req, res, next) => {
    try {
      const data = await queryService.getCoverageStats(req.actor.uid, { date: requireQueryParam('date', req.query.date) });
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/hubs', requireAuth, requirePolicy('hubs.read', 'hub'), async (req, res, next) => {
    try {
      const items = await queryService.listHubs(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/cost-centers', requireAuth, requirePolicy('hubs.read', 'hub'), async (req, res, next) => {
    try {
      const items = await queryService.listCostCenters(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/vendors', requireAuth, requirePolicy('vendors.read', 'vendor'), async (req, res, next) => {
    try {
      const items = await queryService.listVendors(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/vendors/:vendorId/roles', requireAuth, requirePolicy('vendors.read', 'vendor'), async (req, res, next) => {
    try {
      const items = await queryService.listVendorRoles(req.actor.uid, req.params.vendorId);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/hubs/:hubId/managers', requireAuth, requirePolicy('hubs.read', 'hub'), async (req, res, next) => {
    try {
      const items = await queryService.listHubManagers(req.actor.uid, req.params.hubId);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/client/orders/view', requireAuth, requirePolicy('orders.read', 'order'), async (req, res, next) => {
    try {
      const items = await queryService.listOrderItemsByDateRange(req.actor.uid, req.query);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/session', requireAuth, requirePolicy('staff.session.read', 'session'), async (req, res, next) => {
    try {
      const data = await queryService.getStaffSession(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/dashboard', requireAuth, requirePolicy('staff.dashboard.read', 'dashboard'), async (req, res, next) => {
    try {
      const data = await queryService.getStaffDashboard(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/profile-completion', requireAuth, requirePolicy('staff.profile.read', 'staff'), async (req, res, next) => {
    try {
      const data = await queryService.getStaffProfileCompletion(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/availability', requireAuth, requirePolicy('staff.availability.read', 'staff'), async (req, res, next) => {
    try {
      const items = await queryService.listStaffAvailability(req.actor.uid, req.query);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/clock-in/shifts/today', requireAuth, requirePolicy('attendance.read', 'attendance'), async (req, res, next) => {
    try {
      const items = await queryService.listTodayShifts(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/clock-in/status', requireAuth, requirePolicy('attendance.read', 'attendance'), async (req, res, next) => {
    try {
      const data = await queryService.getCurrentAttendanceStatus(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/payments/summary', requireAuth, requirePolicy('payments.read', 'payment'), async (req, res, next) => {
    try {
      const data = await queryService.getPaymentsSummary(req.actor.uid, req.query);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/payments/history', requireAuth, requirePolicy('payments.read', 'payment'), async (req, res, next) => {
    try {
      const items = await queryService.listPaymentsHistory(req.actor.uid, req.query);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/payments/chart', requireAuth, requirePolicy('payments.read', 'payment'), async (req, res, next) => {
    try {
      const items = await queryService.getPaymentChart(req.actor.uid, req.query);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/shifts/assigned', requireAuth, requirePolicy('shifts.read', 'shift'), async (req, res, next) => {
    try {
      const items = await queryService.listAssignedShifts(req.actor.uid, req.query);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/shifts/open', requireAuth, requirePolicy('shifts.read', 'shift'), async (req, res, next) => {
    try {
      const items = await queryService.listOpenShifts(req.actor.uid, req.query);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/shifts/pending', requireAuth, requirePolicy('shifts.read', 'shift'), async (req, res, next) => {
    try {
      const items = await queryService.listPendingAssignments(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/shifts/cancelled', requireAuth, requirePolicy('shifts.read', 'shift'), async (req, res, next) => {
    try {
      const items = await queryService.listCancelledShifts(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/shifts/completed', requireAuth, requirePolicy('shifts.read', 'shift'), async (req, res, next) => {
    try {
      const items = await queryService.listCompletedShifts(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/shifts/:shiftId', requireAuth, requirePolicy('shifts.read', 'shift'), async (req, res, next) => {
    try {
      const data = await queryService.getStaffShiftDetail(req.actor.uid, req.params.shiftId);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/profile/sections', requireAuth, requirePolicy('staff.profile.read', 'staff'), async (req, res, next) => {
    try {
      const data = await queryService.getProfileSectionsStatus(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/profile/personal-info', requireAuth, requirePolicy('staff.profile.read', 'staff'), async (req, res, next) => {
    try {
      const data = await queryService.getPersonalInfo(req.actor.uid);
      return res.status(200).json({ ...data, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/profile/industries', requireAuth, requirePolicy('staff.profile.read', 'staff'), async (req, res, next) => {
    try {
      const items = await queryService.listIndustries(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/profile/skills', requireAuth, requirePolicy('staff.profile.read', 'staff'), async (req, res, next) => {
    try {
      const items = await queryService.listSkills(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/profile/documents', requireAuth, requirePolicy('staff.profile.read', 'staff'), async (req, res, next) => {
    try {
      const items = await queryService.listProfileDocuments(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/profile/certificates', requireAuth, requirePolicy('staff.profile.read', 'staff'), async (req, res, next) => {
    try {
      const items = await queryService.listCertificates(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/profile/bank-accounts', requireAuth, requirePolicy('staff.profile.read', 'staff'), async (req, res, next) => {
    try {
      const items = await queryService.listStaffBankAccounts(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  router.get('/staff/profile/benefits', requireAuth, requirePolicy('staff.profile.read', 'staff'), async (req, res, next) => {
    try {
      const items = await queryService.listStaffBenefits(req.actor.uid);
      return res.status(200).json({ items, requestId: req.requestId });
    } catch (error) {
      return next(error);
    }
  });

  return router;
}