Backend

// prisma/schema.prisma (excerpt)
enum Role           { PATIENT PHARMACIST ADMIN }
enum PharmacyStatus { PENDING VERIFIED REJECTED SUSPENDED }
enum HoldStatus     { ACTIVE COLLECTED CANCELLED EXPIRED }

model Pharmacy {
  id          Int            @id @default(autoincrement())
  owner       User           @relation(fields: [ownerId], references: [id])
  ownerId     Int
  name        String
  address     String
  area        String
  lat         Decimal        @db.Decimal(9, 6)
  lng         Decimal        @db.Decimal(9, 6)
  phone       String
  is24x7      Boolean        @default(false)
  status      PharmacyStatus @default(PENDING)
  credentials Credential[]
  hours       OperatingHours[]
  stock       StockItem[]
  @@index([status, lat, lng])
}

model StockItem {
  id          Int      @id @default(autoincrement())
  pharmacy    Pharmacy @relation(fields: [pharmacyId], references: [id])
  pharmacyId  Int
  medicine    Medicine @relation(fields: [medicineId], references: [id])
  medicineId  Int
  quantity    Int
  price       Decimal  @db.Decimal(8, 2)
  lastUpdated DateTime @default(now())
  mongoSynced Boolean  @default(true)
  holds       Hold[]
  @@unique([pharmacyId, medicineId])
  @@index([medicineId, quantity])
}

// services/HoldService.ts
async placeHold(patientId: number, stockItemId: number) {
  if (await prisma.hold.count({ where: { patientId, status: 'ACTIVE',
                                         expiresAt: { gt: new Date() } } }))
    throw new AppError(409, 'You already have an active hold');

  const hold = await prisma.$transaction(async (tx) => {
    // 1. lazy expiry: old holds on this item give their units back
    const expired = await tx.hold.updateMany({
      where: { stockItemId, status: 'ACTIVE', expiresAt: { lt: new Date() } },
      data:  { status: 'EXPIRED' } });
    if (expired.count) await tx.stockItem.update({ where: { id: stockItemId },
      data: { quantity: { increment: expired.count } } });

    // 2. take one unit only if one is left
    const took = await tx.stockItem.updateMany({
      where: { id: stockItemId, quantity: { gte: 1 } },
      data:  { quantity: { decrement: 1 } } });
    if (took.count === 0) throw new AppError(409, 'Just missed it'); // ROLLBACK

    // 3. record it
    return tx.hold.create({ data: { stockItemId, patientId, status: 'ACTIVE',
      expiresAt: new Date(Date.now() + 30 * 60_000) } });
  });                                                              // COMMIT

  await this.copy.adjust(stockItemId, -1);   // Mongo $inc, after commit
  return hold;
}

// availability: one document per stock item (DE wk 11: embed)
{
  _id: 42,                       // = stock_item.id
  pharmacyId: 3,                 // reference, not embedded
  medicine: { name: "Dolo 650", composition: "Paracetamol 650mg",
              form: "TABLET" },  // embedded copy
  quantity: 4, price: 32, available: true,
  lastUpdated: ISODate("2026-09-28T08:10:00Z")
}

// pharmacies: referenced by availability.pharmacyId
{ _id: 3, name: "City Care Chemist", area: "Sonipat Sector 14",
  lat: 28.9931, lng: 77.0151, is24x7: true, verified: true }

// DE wk 12: search pipeline
db.availability.aggregate([
  { $match:  { "medicine.name": { $regex: q, $options: "i" }, available: true } },
  { $lookup: { from: "pharmacies", localField: "pharmacyId",
               foreignField: "_id", as: "pharmacy" } },
  { $match:  { "pharmacy.verified": true } },
  { $sort:   { lastUpdated: -1 } },
  { $limit:  50 }
])

// DE wk 12: admin report
db.availability.aggregate([
  { $match: { available: false } },
  { $group: { _id: "$medicine.name", pharmacies: { $sum: 1 } } },
  { $sort:  { pharmacies: -1 } }, { $limit: 10 }
])

// utils/AppError.ts
export class AppError extends Error {
  constructor(public status: number, message: string, public details?: unknown) {
    super(message);
    this.name = 'AppError';
  }
}

// utils/asyncHandler.ts: async errors reach next()
export const asyncHandler = (fn: AsyncHandler): RequestHandler =>
  (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);

// middlewares/errorHandler.ts
export const errorHandler: ErrorRequestHandler = (err, _req, res, _next) => {
  if (err?.code === 'P2002') err = new AppError(409, 'Already exists');
  if (err?.code === 'P2025') err = new AppError(404, 'Not found');
  if (err instanceof AppError)
    return res.status(err.status).json({ error: { status: err.status,
      message: err.message, details: err.details } });
  console.error(err);                                  // stack stays on the server
  res.status(500).json({ error: { status: 500, message: 'Something went wrong' } });
};