# docker-compose.yml
mongo:
  image: mongo:7
  ports:
    - "27017:27017"
  volumes:
    - mongo_data:/data/db
  environment:
    MONGO_INITDB_ROOT_USERNAME: simprio
    MONGO_INITDB_ROOT_PASSWORD: mongo_dev_pass

mongodb://simprio:mongo_dev_pass@localhost:27017/simprio_analytics

redis:
  image: redis:7-alpine
  ports:
    - "6379:6379"
  volumes:
    - redis_data:/data

// src/routes/webhooks.routes.ts
import { Router } from 'express'
import crypto from 'crypto'
import { env } from '../config/env'
import { prisma } from '../config/db'

const router = Router()

// Razorpay Webhook
router.post('/razorpay', async (req, res) => {
  const signature = req.headers['x-razorpay-signature']
  const payload = JSON.stringify(req.body)

  // Verify webhook signature
  const expectedSignature = crypto
    .createHmac('sha256', env.razorpay.keySecret)
    .update(payload)
    .digest('hex')

  if (signature !== expectedSignature) {
    return res.status(400).json({ error: 'Invalid signature' })
  }

  const event = req.body.event
  const payment = req.body.payload.payment.entity

  switch (event) {
    case 'payment.captured':
      // Find order by razorpayOrderId and update paymentStatus to success
      await prisma.order.updateMany({
        where: { razorpayOrderId: payment.order_id },
        data: { paymentStatus: 'success', razorpayPaymentId: payment.id }
      })
      break

    case 'payment.failed':
      // Handle failed payment - notify user, log event
      await prisma.order.updateMany({
        where: { razorpayOrderId: payment.order_id },
        data: { paymentStatus: 'failed' }
      })
      break

    case 'refund.created':
      // Update refund status in order
      const refund = req.body.payload.refund.entity
      await prisma.order.updateMany({
        where: { razorpayPaymentId: refund.payment_id },
        data: { paymentStatus: 'refunded' }
      })
      break

    case 'order.paid':
      // Additional order processing
      break
  }

  res.json({ received: true })
})

export default router

// src/routes/payouts.routes.ts
import { Router } from 'express'
import Razorpay from 'razorpay'
import { authenticate, requireAdmin, AuthRequest } from '../middleware/auth'
import { prisma } from '../config/db'
import { env } from '../config/env'

const router = Router()
router.use(authenticate)

const razorpay = new Razorpay({
  key_id: env.razorpay.keyId,
  key_secret: env.razorpay.keySecret
})

// Create bank account for partner (one-time)
router.post('/accounts', requireAdmin, async (req: AuthRequest, res, next) => {
  try {
    const { partnerId, bankCode, accountNumber, accountName, ifscCode } = req.body

    const bankAccount = await razorpay.fundAccounts.create({
      account_type: 'bank_account',
      bank_account: {
        ifsc_code: ifscCode,
        name: accountName,
        account_number: accountNumber
      },
      notes: { partner_id: partnerId }
    })

    // Store fundAccountId in partner record
    await prisma.partner.update({
      where: { id: partnerId },
      data: { bankAccount: { fundId: bankAccount.id, ...req.body } }
    })

    res.json({ fundAccountId: bankAccount.id })
  } catch (err) { next(err) }
})

// Create payout to partner
router.post('/create', requireAdmin, async (req: AuthRequest, res, next) => {
  try {
    const { partnerId, amount, orderId, description } = req.body

    const partner = await prisma.partner.findUnique({ where: { id: partnerId } })
    if (!partner?.bankAccount) {
      return res.status(400).json({ error: 'Partner bank account not configured' })
    }

    const fundAccountId = partner.bankAccount.fundId

    const transfer = await razorpay.transfers.create({
      amount: Math.round(amount * 100),
      currency: 'INR',
      account: fundAccountId,
      settled_at: Math.floor(Date.now() / 1000) + 86400, // Next day
      notes: {
        order_id: orderId,
        partner_id: partnerId,
        description
      }
    })

    // Create payout record
    await prisma.payout.create({
      data: {
        partnerId,
        amount,
        status: 'pending',
        reference: transfer.id
      }
    })

    res.json(transfer)
  } catch (err) { next(err) }
})

// List all payouts
router.get('/list', requireAdmin, async (req: AuthRequest, res, next) => {
  try {
    const payouts = await prisma.payout.findMany({
      include: { partner: { include: { user: true } } },
      orderBy: { createdAt: 'desc' }
    })
    res.json(payouts)
  } catch (err) { next(err) }
})

// Partner withdrawal request
router.post('/withdraw', async (req: AuthRequest, res, next) => {
  try {
    const { amount } = req.body
    const partner = await prisma.partner.findUnique({ where: { userId: req.user!.userId } })

    if (!partner) {
      return res.status(404).json({ error: 'Partner not found' })
    }

    if (!partner.bankAccount) {
      return res.status(400).json({ error: 'Bank account not configured' })
    }

    // Create withdrawal request (admin will process)
    await prisma.payout.create({
      data: {
        partnerId: partner.id,
        amount,
        status: 'requested'
      }
    })

    res.json({ message: 'Withdrawal request submitted' })
  } catch (err) { next(err) }
})

export default router

// Example API integration pattern needed

// Orders - Full CRUD
GET    /api/v1/orders?page=1&limit=20&status=pending
GET    /api/v1/orders/:id
PATCH  /api/v1/orders/:id/status
DELETE /api/v1/orders/:id

// Partners - Full Management
GET    /api/v1/admin/partners?status=pending
GET    /api/v1/admin/partners/:id
PATCH  /api/v1/admin/partners/:id/status (approve/reject)
PATCH  /api/v1/admin/partners/:id (update details)

// Payments
GET    /api/v1/admin/payments?status=pending
GET    /api/v1/admin/payments/:id
POST   /api/v1/admin/payments/:id/refund

// Payouts
GET    /api/v1/payouts/list
POST   /api/v1/payouts/create
PATCH  /api/v1/payouts/:id/status

// Analytics
GET    /api/v1/analytics/dashboard
GET    /api/v1/analytics/revenue?from=&to=
GET    /api/v1/analytics/orders?module=food
GET    /api/v1/analytics/users

// Reports
GET    /api/v1/reports/orders?format=csv&from=&to=
GET    /api/v1/reports/revenue?format=csv
GET    /api/v1/reports/partners?format=csv

// Orders
GET    /api/v1/partner/orders?status=pending&module=food
GET    /api/v1/partner/orders/:id
PATCH  /api/v1/partner/orders/:id/status (confirm/preparing/ready/cancel)

// Products (Food)
GET    /api/v1/partner/restaurant/:id/dishes
POST   /api/v1/partner/restaurant/:id/dishes
PATCH  /api/v1/partner/dishes/:id
DELETE /api/v1/partner/dishes/:id

// Products (Shopping/Quick/Grocery)
GET    /api/v1/partner/products
POST   /api/v1/partner/products
PATCH  /api/v1/partner/products/:id
DELETE /api/v1/partner/products/:id

// Earnings & Payouts
GET    /api/v1/partner/earnings
GET    /api/v1/partner/payouts
POST   /api/v1/payouts/withdraw

// Profile
GET    /api/v1/partner/profile
PATCH  /api/v1/partner/profile

// Availability
PATCH  /api/v1/partner/availability
PATCH  /api/v1/partner/working-hours

// Bank Account
POST   /api/v1/partner/bank-account
GET    /api/v1/partner/bank-account

// Analytics
GET    /api/v1/partner/analytics/orders
GET    /api/v1/partner/analytics/revenue
GET    /api/v1/partner/analytics/customers

services:
  postgres:
    image: postgres:16-alpine
    ports:
      - '5432:5432'
  api:
    build: .
    ports:
      - '4000:4000'

Render / Railway / Vercel
├── Backend API (Node.js)
├── PostgreSQL (Railway/RDS)
├── S3 Storage (Uploads)
└── CDN (CloudFront)

AWS / GCP
├── Load Balancer (ALB)
├── Kubernetes Cluster (EKS/GKE)
│   ├── API Pods (3+ replicas)
│   ├── HPA (auto-scaling)
│   └── ConfigMaps/Secrets
├── PostgreSQL (RDS Aurora)
├── Redis (ElastiCache)
├── S3 (Files)
├── CloudFront (CDN)
├── Route53 (DNS)
└── ACM (SSL)